// $ANTLR 3.4 C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g 2013-01-10 15:54:21
package com.nebrija.riif.parser;

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

import org.antlr.runtime.tree.*;


@SuppressWarnings({"all", "warnings", "unchecked"})
public class RIIFParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ASSERT", "ASSIGN", "Attr_ident", "CHILD_COMPONENT", "COMMENT", "COMPONENT", "CONSTANT", "DIGIT", "DecimalLiteral", "END_COMPONENT", "END_ENVIRONMENT", "END_REQUIREMENT", "END_TIMELINE", "ENVIRONMENT", "EXPRESS_TIME", "EXTENDS", "EscapeSequence", "Exponent", "FAIL_MODE", "FUNC_AGG_SINGLE", "FUNC_EXP", "FUNC_GT_N_FAIL", "FUNC_LOG", "FloatTypeSuffix", "FloatingPointLiteral", "GET_TRANSITION", "GET_TRANSITION_TIME", "GET_VALUE", "HexDigit", "Hier_ident", "INITIAL", "INPUT", "Ident", "LETTER", "LINE_COMMENT", "OUTPUT", "OctalEscape", "PARAMETER", "POW", "REQUIREMENT", "STATE", "StringLiteral", "TERMINAL", "TIMELINE", "TYPE_ENUM", "TYPE_FLOAT", "TYPE_INTEGER", "TYPE_STRING", "UNDERSCORE", "UNIT_CDEGREES", "UNIT_FITS", "UNIT_VOLTS", "UnicodeEscape", "WS", "'!'", "'!='", "'%'", "'&&'", "'&'", "'('", "')'", "'*'", "'+'", "','", "'-'", "'/'", "':'", "':='", "';'", "'<'", "'='", "'=='", "'>'", "'?'", "'['", "']'", "'^'", "'{'", "'|'", "'||'", "'}'", "'~'"
    };

    public static final int EOF=-1;
    public static final int T__58=58;
    public static final int T__59=59;
    public static final int T__60=60;
    public static final int T__61=61;
    public static final int T__62=62;
    public static final int T__63=63;
    public static final int T__64=64;
    public static final int T__65=65;
    public static final int T__66=66;
    public static final int T__67=67;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__70=70;
    public static final int T__71=71;
    public static final int T__72=72;
    public static final int T__73=73;
    public static final int T__74=74;
    public static final int T__75=75;
    public static final int T__76=76;
    public static final int T__77=77;
    public static final int T__78=78;
    public static final int T__79=79;
    public static final int T__80=80;
    public static final int T__81=81;
    public static final int T__82=82;
    public static final int T__83=83;
    public static final int T__84=84;
    public static final int T__85=85;
    public static final int ASSERT=4;
    public static final int ASSIGN=5;
    public static final int Attr_ident=6;
    public static final int CHILD_COMPONENT=7;
    public static final int COMMENT=8;
    public static final int COMPONENT=9;
    public static final int CONSTANT=10;
    public static final int DIGIT=11;
    public static final int DecimalLiteral=12;
    public static final int END_COMPONENT=13;
    public static final int END_ENVIRONMENT=14;
    public static final int END_REQUIREMENT=15;
    public static final int END_TIMELINE=16;
    public static final int ENVIRONMENT=17;
    public static final int EXPRESS_TIME=18;
    public static final int EXTENDS=19;
    public static final int EscapeSequence=20;
    public static final int Exponent=21;
    public static final int FAIL_MODE=22;
    public static final int FUNC_AGG_SINGLE=23;
    public static final int FUNC_EXP=24;
    public static final int FUNC_GT_N_FAIL=25;
    public static final int FUNC_LOG=26;
    public static final int FloatTypeSuffix=27;
    public static final int FloatingPointLiteral=28;
    public static final int GET_TRANSITION=29;
    public static final int GET_TRANSITION_TIME=30;
    public static final int GET_VALUE=31;
    public static final int HexDigit=32;
    public static final int Hier_ident=33;
    public static final int INITIAL=34;
    public static final int INPUT=35;
    public static final int Ident=36;
    public static final int LETTER=37;
    public static final int LINE_COMMENT=38;
    public static final int OUTPUT=39;
    public static final int OctalEscape=40;
    public static final int PARAMETER=41;
    public static final int POW=42;
    public static final int REQUIREMENT=43;
    public static final int STATE=44;
    public static final int StringLiteral=45;
    public static final int TERMINAL=46;
    public static final int TIMELINE=47;
    public static final int TYPE_ENUM=48;
    public static final int TYPE_FLOAT=49;
    public static final int TYPE_INTEGER=50;
    public static final int TYPE_STRING=51;
    public static final int UNDERSCORE=52;
    public static final int UNIT_CDEGREES=53;
    public static final int UNIT_FITS=54;
    public static final int UNIT_VOLTS=55;
    public static final int UnicodeEscape=56;
    public static final int WS=57;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public RIIFParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public RIIFParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return RIIFParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g"; }


    public static class program_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "program"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:81:1: program : ( declaration )+ ;
    public final RIIFParser.program_return program() throws RecognitionException {
        RIIFParser.program_return retval = new RIIFParser.program_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.declaration_return declaration1 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:82:5: ( ( declaration )+ )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:82:9: ( declaration )+
            {
            root_0 = (Object)adaptor.nil();


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:82:9: ( declaration )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==COMPONENT||LA1_0==ENVIRONMENT||LA1_0==REQUIREMENT||LA1_0==TIMELINE) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:82:9: declaration
            	    {
            	    pushFollow(FOLLOW_declaration_in_program660);
            	    declaration1=declaration();

            	    state._fsp--;

            	    adaptor.addChild(root_0, declaration1.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "program"


    public static class declaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "declaration"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:85:1: declaration : ( component_decl | environment_decl | requirement_decl | timeline_decl );
    public final RIIFParser.declaration_return declaration() throws RecognitionException {
        RIIFParser.declaration_return retval = new RIIFParser.declaration_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.component_decl_return component_decl2 =null;

        RIIFParser.environment_decl_return environment_decl3 =null;

        RIIFParser.requirement_decl_return requirement_decl4 =null;

        RIIFParser.timeline_decl_return timeline_decl5 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:86:5: ( component_decl | environment_decl | requirement_decl | timeline_decl )
            int alt2=4;
            switch ( input.LA(1) ) {
            case COMPONENT:
                {
                alt2=1;
                }
                break;
            case ENVIRONMENT:
                {
                alt2=2;
                }
                break;
            case REQUIREMENT:
                {
                alt2=3;
                }
                break;
            case TIMELINE:
                {
                alt2=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;

            }

            switch (alt2) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:86:7: component_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_component_decl_in_declaration678);
                    component_decl2=component_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, component_decl2.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:87:7: environment_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_environment_decl_in_declaration686);
                    environment_decl3=environment_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, environment_decl3.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:88:7: requirement_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_requirement_decl_in_declaration694);
                    requirement_decl4=requirement_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, requirement_decl4.getTree());

                    }
                    break;
                case 4 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:89:7: timeline_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_timeline_decl_in_declaration702);
                    timeline_decl5=timeline_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, timeline_decl5.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "declaration"


    public static class component_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "component_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:94:1: component_decl : COMPONENT ident ( EXTENDS ident )? ';' ( component_body_element )* END_COMPONENT -> ^( COMPONENT ident ( ^( EXTENDS ident ) )? ( component_body_element )* ) ;
    public final RIIFParser.component_decl_return component_decl() throws RecognitionException {
        RIIFParser.component_decl_return retval = new RIIFParser.component_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token COMPONENT6=null;
        Token EXTENDS8=null;
        Token char_literal10=null;
        Token END_COMPONENT12=null;
        RIIFParser.ident_return ident7 =null;

        RIIFParser.ident_return ident9 =null;

        RIIFParser.component_body_element_return component_body_element11 =null;


        Object COMPONENT6_tree=null;
        Object EXTENDS8_tree=null;
        Object char_literal10_tree=null;
        Object END_COMPONENT12_tree=null;
        RewriteRuleTokenStream stream_COMPONENT=new RewriteRuleTokenStream(adaptor,"token COMPONENT");
        RewriteRuleTokenStream stream_EXTENDS=new RewriteRuleTokenStream(adaptor,"token EXTENDS");
        RewriteRuleTokenStream stream_END_COMPONENT=new RewriteRuleTokenStream(adaptor,"token END_COMPONENT");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_component_body_element=new RewriteRuleSubtreeStream(adaptor,"rule component_body_element");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:95:5: ( COMPONENT ident ( EXTENDS ident )? ';' ( component_body_element )* END_COMPONENT -> ^( COMPONENT ident ( ^( EXTENDS ident ) )? ( component_body_element )* ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:95:9: COMPONENT ident ( EXTENDS ident )? ';' ( component_body_element )* END_COMPONENT
            {
            COMPONENT6=(Token)match(input,COMPONENT,FOLLOW_COMPONENT_in_component_decl724);  
            stream_COMPONENT.add(COMPONENT6);


            pushFollow(FOLLOW_ident_in_component_decl726);
            ident7=ident();

            state._fsp--;

            stream_ident.add(ident7.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:95:25: ( EXTENDS ident )?
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==EXTENDS) ) {
                alt3=1;
            }
            switch (alt3) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:95:27: EXTENDS ident
                    {
                    EXTENDS8=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_component_decl730);  
                    stream_EXTENDS.add(EXTENDS8);


                    pushFollow(FOLLOW_ident_in_component_decl732);
                    ident9=ident();

                    state._fsp--;

                    stream_ident.add(ident9.getTree());

                    }
                    break;

            }


            char_literal10=(Token)match(input,72,FOLLOW_72_in_component_decl738);  
            stream_72.add(char_literal10);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:95:49: ( component_body_element )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( ((LA4_0 >= ASSERT && LA4_0 <= ASSIGN)||LA4_0==CHILD_COMPONENT||LA4_0==CONSTANT||LA4_0==FAIL_MODE||LA4_0==PARAMETER) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:95:49: component_body_element
            	    {
            	    pushFollow(FOLLOW_component_body_element_in_component_decl740);
            	    component_body_element11=component_body_element();

            	    state._fsp--;

            	    stream_component_body_element.add(component_body_element11.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            END_COMPONENT12=(Token)match(input,END_COMPONENT,FOLLOW_END_COMPONENT_in_component_decl745);  
            stream_END_COMPONENT.add(END_COMPONENT12);


            // AST REWRITE
            // elements: ident, component_body_element, EXTENDS, ident, COMPONENT
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 96:9: -> ^( COMPONENT ident ( ^( EXTENDS ident ) )? ( component_body_element )* )
            {
                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:96:12: ^( COMPONENT ident ( ^( EXTENDS ident ) )? ( component_body_element )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                stream_COMPONENT.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_ident.nextTree());

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:96:31: ( ^( EXTENDS ident ) )?
                if ( stream_EXTENDS.hasNext()||stream_ident.hasNext() ) {
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:96:31: ^( EXTENDS ident )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    stream_EXTENDS.nextNode()
                    , root_2);

                    adaptor.addChild(root_2, stream_ident.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_EXTENDS.reset();
                stream_ident.reset();

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:96:51: ( component_body_element )*
                while ( stream_component_body_element.hasNext() ) {
                    adaptor.addChild(root_1, stream_component_body_element.nextTree());

                }
                stream_component_body_element.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "component_decl"


    public static class component_body_element_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "component_body_element"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:99:1: component_body_element : ( parameter_decl | constant_decl | child_component_decl | fail_mode_decl | assignment | assertion );
    public final RIIFParser.component_body_element_return component_body_element() throws RecognitionException {
        RIIFParser.component_body_element_return retval = new RIIFParser.component_body_element_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.parameter_decl_return parameter_decl13 =null;

        RIIFParser.constant_decl_return constant_decl14 =null;

        RIIFParser.child_component_decl_return child_component_decl15 =null;

        RIIFParser.fail_mode_decl_return fail_mode_decl16 =null;

        RIIFParser.assignment_return assignment17 =null;

        RIIFParser.assertion_return assertion18 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:100:4: ( parameter_decl | constant_decl | child_component_decl | fail_mode_decl | assignment | assertion )
            int alt5=6;
            switch ( input.LA(1) ) {
            case PARAMETER:
                {
                alt5=1;
                }
                break;
            case CONSTANT:
                {
                alt5=2;
                }
                break;
            case CHILD_COMPONENT:
                {
                alt5=3;
                }
                break;
            case FAIL_MODE:
                {
                alt5=4;
                }
                break;
            case ASSIGN:
                {
                alt5=5;
                }
                break;
            case ASSERT:
                {
                alt5=6;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;

            }

            switch (alt5) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:100:6: parameter_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_parameter_decl_in_component_body_element791);
                    parameter_decl13=parameter_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, parameter_decl13.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:101:6: constant_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_constant_decl_in_component_body_element798);
                    constant_decl14=constant_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, constant_decl14.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:102:6: child_component_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_child_component_decl_in_component_body_element805);
                    child_component_decl15=child_component_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, child_component_decl15.getTree());

                    }
                    break;
                case 4 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:103:6: fail_mode_decl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_fail_mode_decl_in_component_body_element812);
                    fail_mode_decl16=fail_mode_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, fail_mode_decl16.getTree());

                    }
                    break;
                case 5 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:104:6: assignment
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_assignment_in_component_body_element819);
                    assignment17=assignment();

                    state._fsp--;

                    adaptor.addChild(root_0, assignment17.getTree());

                    }
                    break;
                case 6 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:105:6: assertion
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_assertion_in_component_body_element827);
                    assertion18=assertion();

                    state._fsp--;

                    adaptor.addChild(root_0, assertion18.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "component_body_element"


    public static class environment_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "environment_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:109:1: environment_decl : ENVIRONMENT ident ';' ( environment_body_element )* END_ENVIRONMENT -> ^( ENVIRONMENT ident ( environment_body_element )* ) ;
    public final RIIFParser.environment_decl_return environment_decl() throws RecognitionException {
        RIIFParser.environment_decl_return retval = new RIIFParser.environment_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token ENVIRONMENT19=null;
        Token char_literal21=null;
        Token END_ENVIRONMENT23=null;
        RIIFParser.ident_return ident20 =null;

        RIIFParser.environment_body_element_return environment_body_element22 =null;


        Object ENVIRONMENT19_tree=null;
        Object char_literal21_tree=null;
        Object END_ENVIRONMENT23_tree=null;
        RewriteRuleTokenStream stream_END_ENVIRONMENT=new RewriteRuleTokenStream(adaptor,"token END_ENVIRONMENT");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleTokenStream stream_ENVIRONMENT=new RewriteRuleTokenStream(adaptor,"token ENVIRONMENT");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_environment_body_element=new RewriteRuleSubtreeStream(adaptor,"rule environment_body_element");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:110:5: ( ENVIRONMENT ident ';' ( environment_body_element )* END_ENVIRONMENT -> ^( ENVIRONMENT ident ( environment_body_element )* ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:110:7: ENVIRONMENT ident ';' ( environment_body_element )* END_ENVIRONMENT
            {
            ENVIRONMENT19=(Token)match(input,ENVIRONMENT,FOLLOW_ENVIRONMENT_in_environment_decl844);  
            stream_ENVIRONMENT.add(ENVIRONMENT19);


            pushFollow(FOLLOW_ident_in_environment_decl846);
            ident20=ident();

            state._fsp--;

            stream_ident.add(ident20.getTree());

            char_literal21=(Token)match(input,72,FOLLOW_72_in_environment_decl848);  
            stream_72.add(char_literal21);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:110:29: ( environment_body_element )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==ASSIGN||LA6_0==CONSTANT||LA6_0==PARAMETER) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:110:29: environment_body_element
            	    {
            	    pushFollow(FOLLOW_environment_body_element_in_environment_decl850);
            	    environment_body_element22=environment_body_element();

            	    state._fsp--;

            	    stream_environment_body_element.add(environment_body_element22.getTree());

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            END_ENVIRONMENT23=(Token)match(input,END_ENVIRONMENT,FOLLOW_END_ENVIRONMENT_in_environment_decl854);  
            stream_END_ENVIRONMENT.add(END_ENVIRONMENT23);


            // AST REWRITE
            // elements: environment_body_element, ident, ENVIRONMENT
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 111:5: -> ^( ENVIRONMENT ident ( environment_body_element )* )
            {
                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:111:8: ^( ENVIRONMENT ident ( environment_body_element )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                stream_ENVIRONMENT.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_ident.nextTree());

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:111:29: ( environment_body_element )*
                while ( stream_environment_body_element.hasNext() ) {
                    adaptor.addChild(root_1, stream_environment_body_element.nextTree());

                }
                stream_environment_body_element.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "environment_decl"


    public static class environment_body_element_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "environment_body_element"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:114:1: environment_body_element : ( parameter_decl | constant_decl | assignment ) ;
    public final RIIFParser.environment_body_element_return environment_body_element() throws RecognitionException {
        RIIFParser.environment_body_element_return retval = new RIIFParser.environment_body_element_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.parameter_decl_return parameter_decl24 =null;

        RIIFParser.constant_decl_return constant_decl25 =null;

        RIIFParser.assignment_return assignment26 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:115:5: ( ( parameter_decl | constant_decl | assignment ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:115:7: ( parameter_decl | constant_decl | assignment )
            {
            root_0 = (Object)adaptor.nil();


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:115:7: ( parameter_decl | constant_decl | assignment )
            int alt7=3;
            switch ( input.LA(1) ) {
            case PARAMETER:
                {
                alt7=1;
                }
                break;
            case CONSTANT:
                {
                alt7=2;
                }
                break;
            case ASSIGN:
                {
                alt7=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;

            }

            switch (alt7) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:115:9: parameter_decl
                    {
                    pushFollow(FOLLOW_parameter_decl_in_environment_body_element890);
                    parameter_decl24=parameter_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, parameter_decl24.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:115:26: constant_decl
                    {
                    pushFollow(FOLLOW_constant_decl_in_environment_body_element894);
                    constant_decl25=constant_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, constant_decl25.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:115:42: assignment
                    {
                    pushFollow(FOLLOW_assignment_in_environment_body_element898);
                    assignment26=assignment();

                    state._fsp--;

                    adaptor.addChild(root_0, assignment26.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "environment_body_element"


    public static class requirement_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "requirement_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:118:1: requirement_decl : REQUIREMENT ident ';' ( assertion )* END_REQUIREMENT ;
    public final RIIFParser.requirement_decl_return requirement_decl() throws RecognitionException {
        RIIFParser.requirement_decl_return retval = new RIIFParser.requirement_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token REQUIREMENT27=null;
        Token char_literal29=null;
        Token END_REQUIREMENT31=null;
        RIIFParser.ident_return ident28 =null;

        RIIFParser.assertion_return assertion30 =null;


        Object REQUIREMENT27_tree=null;
        Object char_literal29_tree=null;
        Object END_REQUIREMENT31_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:119:5: ( REQUIREMENT ident ';' ( assertion )* END_REQUIREMENT )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:119:7: REQUIREMENT ident ';' ( assertion )* END_REQUIREMENT
            {
            root_0 = (Object)adaptor.nil();


            REQUIREMENT27=(Token)match(input,REQUIREMENT,FOLLOW_REQUIREMENT_in_requirement_decl915); 
            REQUIREMENT27_tree = 
            (Object)adaptor.create(REQUIREMENT27)
            ;
            adaptor.addChild(root_0, REQUIREMENT27_tree);


            pushFollow(FOLLOW_ident_in_requirement_decl917);
            ident28=ident();

            state._fsp--;

            adaptor.addChild(root_0, ident28.getTree());

            char_literal29=(Token)match(input,72,FOLLOW_72_in_requirement_decl919); 
            char_literal29_tree = 
            (Object)adaptor.create(char_literal29)
            ;
            adaptor.addChild(root_0, char_literal29_tree);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:119:29: ( assertion )*
            loop8:
            do {
                int alt8=2;
                int LA8_0 = input.LA(1);

                if ( (LA8_0==ASSERT) ) {
                    alt8=1;
                }


                switch (alt8) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:119:29: assertion
            	    {
            	    pushFollow(FOLLOW_assertion_in_requirement_decl921);
            	    assertion30=assertion();

            	    state._fsp--;

            	    adaptor.addChild(root_0, assertion30.getTree());

            	    }
            	    break;

            	default :
            	    break loop8;
                }
            } while (true);


            END_REQUIREMENT31=(Token)match(input,END_REQUIREMENT,FOLLOW_END_REQUIREMENT_in_requirement_decl925); 
            END_REQUIREMENT31_tree = 
            (Object)adaptor.create(END_REQUIREMENT31)
            ;
            adaptor.addChild(root_0, END_REQUIREMENT31_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "requirement_decl"


    public static class timeline_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "timeline_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:123:1: timeline_decl : TIMELINE ident ';' ( timeline_body_element )* END_TIMELINE -> ^( TIMELINE ident ( timeline_body_element )* ) ;
    public final RIIFParser.timeline_decl_return timeline_decl() throws RecognitionException {
        RIIFParser.timeline_decl_return retval = new RIIFParser.timeline_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token TIMELINE32=null;
        Token char_literal34=null;
        Token END_TIMELINE36=null;
        RIIFParser.ident_return ident33 =null;

        RIIFParser.timeline_body_element_return timeline_body_element35 =null;


        Object TIMELINE32_tree=null;
        Object char_literal34_tree=null;
        Object END_TIMELINE36_tree=null;
        RewriteRuleTokenStream stream_END_TIMELINE=new RewriteRuleTokenStream(adaptor,"token END_TIMELINE");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleTokenStream stream_TIMELINE=new RewriteRuleTokenStream(adaptor,"token TIMELINE");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_timeline_body_element=new RewriteRuleSubtreeStream(adaptor,"rule timeline_body_element");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:124:5: ( TIMELINE ident ';' ( timeline_body_element )* END_TIMELINE -> ^( TIMELINE ident ( timeline_body_element )* ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:124:9: TIMELINE ident ';' ( timeline_body_element )* END_TIMELINE
            {
            TIMELINE32=(Token)match(input,TIMELINE,FOLLOW_TIMELINE_in_timeline_decl943);  
            stream_TIMELINE.add(TIMELINE32);


            pushFollow(FOLLOW_ident_in_timeline_decl945);
            ident33=ident();

            state._fsp--;

            stream_ident.add(ident33.getTree());

            char_literal34=(Token)match(input,72,FOLLOW_72_in_timeline_decl947);  
            stream_72.add(char_literal34);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:124:28: ( timeline_body_element )*
            loop9:
            do {
                int alt9=2;
                int LA9_0 = input.LA(1);

                if ( (LA9_0==ASSIGN||LA9_0==INITIAL||LA9_0==STATE||LA9_0==TERMINAL) ) {
                    alt9=1;
                }


                switch (alt9) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:124:28: timeline_body_element
            	    {
            	    pushFollow(FOLLOW_timeline_body_element_in_timeline_decl949);
            	    timeline_body_element35=timeline_body_element();

            	    state._fsp--;

            	    stream_timeline_body_element.add(timeline_body_element35.getTree());

            	    }
            	    break;

            	default :
            	    break loop9;
                }
            } while (true);


            END_TIMELINE36=(Token)match(input,END_TIMELINE,FOLLOW_END_TIMELINE_in_timeline_decl954);  
            stream_END_TIMELINE.add(END_TIMELINE36);


            // AST REWRITE
            // elements: ident, TIMELINE, timeline_body_element
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 125:9: -> ^( TIMELINE ident ( timeline_body_element )* )
            {
                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:125:12: ^( TIMELINE ident ( timeline_body_element )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                stream_TIMELINE.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_ident.nextTree());

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:125:30: ( timeline_body_element )*
                while ( stream_timeline_body_element.hasNext() ) {
                    adaptor.addChild(root_1, stream_timeline_body_element.nextTree());

                }
                stream_timeline_body_element.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "timeline_decl"


    public static class timeline_body_element_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "timeline_body_element"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:128:1: timeline_body_element : ( state_decl | assignment ) ;
    public final RIIFParser.timeline_body_element_return timeline_body_element() throws RecognitionException {
        RIIFParser.timeline_body_element_return retval = new RIIFParser.timeline_body_element_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.state_decl_return state_decl37 =null;

        RIIFParser.assignment_return assignment38 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:129:5: ( ( state_decl | assignment ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:129:7: ( state_decl | assignment )
            {
            root_0 = (Object)adaptor.nil();


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:129:7: ( state_decl | assignment )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==INITIAL||LA10_0==STATE||LA10_0==TERMINAL) ) {
                alt10=1;
            }
            else if ( (LA10_0==ASSIGN) ) {
                alt10=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;

            }
            switch (alt10) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:129:9: state_decl
                    {
                    pushFollow(FOLLOW_state_decl_in_timeline_body_element994);
                    state_decl37=state_decl();

                    state._fsp--;

                    adaptor.addChild(root_0, state_decl37.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:129:22: assignment
                    {
                    pushFollow(FOLLOW_assignment_in_timeline_body_element998);
                    assignment38=assignment();

                    state._fsp--;

                    adaptor.addChild(root_0, assignment38.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "timeline_body_element"


    public static class parameter_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "parameter_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:133:1: parameter_decl : ( PARAMETER ident ':' complex_type ';' -> ^( PARAMETER ident complex_type ) | PARAMETER ident ':' complex_type ':=' expression ';' -> ^( PARAMETER ident complex_type expression ) );
    public final RIIFParser.parameter_decl_return parameter_decl() throws RecognitionException {
        RIIFParser.parameter_decl_return retval = new RIIFParser.parameter_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token PARAMETER39=null;
        Token char_literal41=null;
        Token char_literal43=null;
        Token PARAMETER44=null;
        Token char_literal46=null;
        Token string_literal48=null;
        Token char_literal50=null;
        RIIFParser.ident_return ident40 =null;

        RIIFParser.complex_type_return complex_type42 =null;

        RIIFParser.ident_return ident45 =null;

        RIIFParser.complex_type_return complex_type47 =null;

        RIIFParser.expression_return expression49 =null;


        Object PARAMETER39_tree=null;
        Object char_literal41_tree=null;
        Object char_literal43_tree=null;
        Object PARAMETER44_tree=null;
        Object char_literal46_tree=null;
        Object string_literal48_tree=null;
        Object char_literal50_tree=null;
        RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
        RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleTokenStream stream_PARAMETER=new RewriteRuleTokenStream(adaptor,"token PARAMETER");
        RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_complex_type=new RewriteRuleSubtreeStream(adaptor,"rule complex_type");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:134:5: ( PARAMETER ident ':' complex_type ';' -> ^( PARAMETER ident complex_type ) | PARAMETER ident ':' complex_type ':=' expression ';' -> ^( PARAMETER ident complex_type expression ) )
            int alt11=2;
            alt11 = dfa11.predict(input);
            switch (alt11) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:134:7: PARAMETER ident ':' complex_type ';'
                    {
                    PARAMETER39=(Token)match(input,PARAMETER,FOLLOW_PARAMETER_in_parameter_decl1016);  
                    stream_PARAMETER.add(PARAMETER39);


                    pushFollow(FOLLOW_ident_in_parameter_decl1018);
                    ident40=ident();

                    state._fsp--;

                    stream_ident.add(ident40.getTree());

                    char_literal41=(Token)match(input,70,FOLLOW_70_in_parameter_decl1020);  
                    stream_70.add(char_literal41);


                    pushFollow(FOLLOW_complex_type_in_parameter_decl1022);
                    complex_type42=complex_type();

                    state._fsp--;

                    stream_complex_type.add(complex_type42.getTree());

                    char_literal43=(Token)match(input,72,FOLLOW_72_in_parameter_decl1024);  
                    stream_72.add(char_literal43);


                    // AST REWRITE
                    // elements: ident, complex_type, PARAMETER
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 134:44: -> ^( PARAMETER ident complex_type )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:134:48: ^( PARAMETER ident complex_type )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_PARAMETER.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_complex_type.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:135:8: PARAMETER ident ':' complex_type ':=' expression ';'
                    {
                    PARAMETER44=(Token)match(input,PARAMETER,FOLLOW_PARAMETER_in_parameter_decl1046);  
                    stream_PARAMETER.add(PARAMETER44);


                    pushFollow(FOLLOW_ident_in_parameter_decl1048);
                    ident45=ident();

                    state._fsp--;

                    stream_ident.add(ident45.getTree());

                    char_literal46=(Token)match(input,70,FOLLOW_70_in_parameter_decl1050);  
                    stream_70.add(char_literal46);


                    pushFollow(FOLLOW_complex_type_in_parameter_decl1052);
                    complex_type47=complex_type();

                    state._fsp--;

                    stream_complex_type.add(complex_type47.getTree());

                    string_literal48=(Token)match(input,71,FOLLOW_71_in_parameter_decl1055);  
                    stream_71.add(string_literal48);


                    pushFollow(FOLLOW_expression_in_parameter_decl1057);
                    expression49=expression();

                    state._fsp--;

                    stream_expression.add(expression49.getTree());

                    char_literal50=(Token)match(input,72,FOLLOW_72_in_parameter_decl1060);  
                    stream_72.add(char_literal50);


                    // AST REWRITE
                    // elements: expression, complex_type, PARAMETER, ident
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 135:63: -> ^( PARAMETER ident complex_type expression )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:135:66: ^( PARAMETER ident complex_type expression )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_PARAMETER.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_complex_type.nextTree());

                        adaptor.addChild(root_1, stream_expression.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "parameter_decl"


    public static class env_parameter_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "env_parameter_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:137:1: env_parameter_decl : ( INPUT | OUTPUT ) PARAMETER ident ':' complex_type ( ':=' expression )? ';' ;
    public final RIIFParser.env_parameter_decl_return env_parameter_decl() throws RecognitionException {
        RIIFParser.env_parameter_decl_return retval = new RIIFParser.env_parameter_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set51=null;
        Token PARAMETER52=null;
        Token char_literal54=null;
        Token string_literal56=null;
        Token char_literal58=null;
        RIIFParser.ident_return ident53 =null;

        RIIFParser.complex_type_return complex_type55 =null;

        RIIFParser.expression_return expression57 =null;


        Object set51_tree=null;
        Object PARAMETER52_tree=null;
        Object char_literal54_tree=null;
        Object string_literal56_tree=null;
        Object char_literal58_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:138:5: ( ( INPUT | OUTPUT ) PARAMETER ident ':' complex_type ( ':=' expression )? ';' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:138:7: ( INPUT | OUTPUT ) PARAMETER ident ':' complex_type ( ':=' expression )? ';'
            {
            root_0 = (Object)adaptor.nil();


            set51=(Token)input.LT(1);

            if ( input.LA(1)==INPUT||input.LA(1)==OUTPUT ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set51)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            PARAMETER52=(Token)match(input,PARAMETER,FOLLOW_PARAMETER_in_env_parameter_decl1101); 
            PARAMETER52_tree = 
            (Object)adaptor.create(PARAMETER52)
            ;
            adaptor.addChild(root_0, PARAMETER52_tree);


            pushFollow(FOLLOW_ident_in_env_parameter_decl1103);
            ident53=ident();

            state._fsp--;

            adaptor.addChild(root_0, ident53.getTree());

            char_literal54=(Token)match(input,70,FOLLOW_70_in_env_parameter_decl1105); 
            char_literal54_tree = 
            (Object)adaptor.create(char_literal54)
            ;
            adaptor.addChild(root_0, char_literal54_tree);


            pushFollow(FOLLOW_complex_type_in_env_parameter_decl1107);
            complex_type55=complex_type();

            state._fsp--;

            adaptor.addChild(root_0, complex_type55.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:138:59: ( ':=' expression )?
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==71) ) {
                alt12=1;
            }
            switch (alt12) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:138:61: ':=' expression
                    {
                    string_literal56=(Token)match(input,71,FOLLOW_71_in_env_parameter_decl1111); 
                    string_literal56_tree = 
                    (Object)adaptor.create(string_literal56)
                    ;
                    adaptor.addChild(root_0, string_literal56_tree);


                    pushFollow(FOLLOW_expression_in_env_parameter_decl1113);
                    expression57=expression();

                    state._fsp--;

                    adaptor.addChild(root_0, expression57.getTree());

                    }
                    break;

            }


            char_literal58=(Token)match(input,72,FOLLOW_72_in_env_parameter_decl1119); 
            char_literal58_tree = 
            (Object)adaptor.create(char_literal58)
            ;
            adaptor.addChild(root_0, char_literal58_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "env_parameter_decl"


    public static class constant_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "constant_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:141:1: constant_decl : ( CONSTANT ident ':' primitive_type ';' -> ^( CONSTANT ident primitive_type ) | CONSTANT ident ':' primitive_type ':=' expression ';' -> ^( CONSTANT ident primitive_type expression ) );
    public final RIIFParser.constant_decl_return constant_decl() throws RecognitionException {
        RIIFParser.constant_decl_return retval = new RIIFParser.constant_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token CONSTANT59=null;
        Token char_literal61=null;
        Token char_literal63=null;
        Token CONSTANT64=null;
        Token char_literal66=null;
        Token string_literal68=null;
        Token char_literal70=null;
        RIIFParser.ident_return ident60 =null;

        RIIFParser.primitive_type_return primitive_type62 =null;

        RIIFParser.ident_return ident65 =null;

        RIIFParser.primitive_type_return primitive_type67 =null;

        RIIFParser.expression_return expression69 =null;


        Object CONSTANT59_tree=null;
        Object char_literal61_tree=null;
        Object char_literal63_tree=null;
        Object CONSTANT64_tree=null;
        Object char_literal66_tree=null;
        Object string_literal68_tree=null;
        Object char_literal70_tree=null;
        RewriteRuleTokenStream stream_CONSTANT=new RewriteRuleTokenStream(adaptor,"token CONSTANT");
        RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
        RewriteRuleTokenStream stream_71=new RewriteRuleTokenStream(adaptor,"token 71");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_primitive_type=new RewriteRuleSubtreeStream(adaptor,"rule primitive_type");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:142:4: ( CONSTANT ident ':' primitive_type ';' -> ^( CONSTANT ident primitive_type ) | CONSTANT ident ':' primitive_type ':=' expression ';' -> ^( CONSTANT ident primitive_type expression ) )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==CONSTANT) ) {
                int LA13_1 = input.LA(2);

                if ( (LA13_1==Ident) ) {
                    int LA13_2 = input.LA(3);

                    if ( (LA13_2==70) ) {
                        int LA13_3 = input.LA(4);

                        if ( ((LA13_3 >= TYPE_FLOAT && LA13_3 <= TYPE_STRING)) ) {
                            int LA13_4 = input.LA(5);

                            if ( (LA13_4==72) ) {
                                alt13=1;
                            }
                            else if ( (LA13_4==71) ) {
                                alt13=2;
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 13, 4, input);

                                throw nvae;

                            }
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 13, 3, input);

                            throw nvae;

                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 13, 2, input);

                        throw nvae;

                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 13, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;

            }
            switch (alt13) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:142:6: CONSTANT ident ':' primitive_type ';'
                    {
                    CONSTANT59=(Token)match(input,CONSTANT,FOLLOW_CONSTANT_in_constant_decl1133);  
                    stream_CONSTANT.add(CONSTANT59);


                    pushFollow(FOLLOW_ident_in_constant_decl1135);
                    ident60=ident();

                    state._fsp--;

                    stream_ident.add(ident60.getTree());

                    char_literal61=(Token)match(input,70,FOLLOW_70_in_constant_decl1137);  
                    stream_70.add(char_literal61);


                    pushFollow(FOLLOW_primitive_type_in_constant_decl1139);
                    primitive_type62=primitive_type();

                    state._fsp--;

                    stream_primitive_type.add(primitive_type62.getTree());

                    char_literal63=(Token)match(input,72,FOLLOW_72_in_constant_decl1141);  
                    stream_72.add(char_literal63);


                    // AST REWRITE
                    // elements: CONSTANT, ident, primitive_type
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 142:44: -> ^( CONSTANT ident primitive_type )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:142:48: ^( CONSTANT ident primitive_type )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_CONSTANT.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_primitive_type.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:143:8: CONSTANT ident ':' primitive_type ':=' expression ';'
                    {
                    CONSTANT64=(Token)match(input,CONSTANT,FOLLOW_CONSTANT_in_constant_decl1163);  
                    stream_CONSTANT.add(CONSTANT64);


                    pushFollow(FOLLOW_ident_in_constant_decl1165);
                    ident65=ident();

                    state._fsp--;

                    stream_ident.add(ident65.getTree());

                    char_literal66=(Token)match(input,70,FOLLOW_70_in_constant_decl1167);  
                    stream_70.add(char_literal66);


                    pushFollow(FOLLOW_primitive_type_in_constant_decl1169);
                    primitive_type67=primitive_type();

                    state._fsp--;

                    stream_primitive_type.add(primitive_type67.getTree());

                    string_literal68=(Token)match(input,71,FOLLOW_71_in_constant_decl1172);  
                    stream_71.add(string_literal68);


                    pushFollow(FOLLOW_expression_in_constant_decl1174);
                    expression69=expression();

                    state._fsp--;

                    stream_expression.add(expression69.getTree());

                    char_literal70=(Token)match(input,72,FOLLOW_72_in_constant_decl1177);  
                    stream_72.add(char_literal70);


                    // AST REWRITE
                    // elements: ident, expression, CONSTANT, primitive_type
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 143:64: -> ^( CONSTANT ident primitive_type expression )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:143:67: ^( CONSTANT ident primitive_type expression )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_CONSTANT.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_primitive_type.nextTree());

                        adaptor.addChild(root_1, stream_expression.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "constant_decl"


    public static class child_component_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "child_component_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:149:1: child_component_decl : ( CHILD_COMPONENT ident ident ';' -> ^( CHILD_COMPONENT ident ident ) | CHILD_COMPONENT ident ident vector ';' -> ^( CHILD_COMPONENT ident ident vector ) );
    public final RIIFParser.child_component_decl_return child_component_decl() throws RecognitionException {
        RIIFParser.child_component_decl_return retval = new RIIFParser.child_component_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token CHILD_COMPONENT71=null;
        Token char_literal74=null;
        Token CHILD_COMPONENT75=null;
        Token char_literal79=null;
        RIIFParser.ident_return ident72 =null;

        RIIFParser.ident_return ident73 =null;

        RIIFParser.ident_return ident76 =null;

        RIIFParser.ident_return ident77 =null;

        RIIFParser.vector_return vector78 =null;


        Object CHILD_COMPONENT71_tree=null;
        Object char_literal74_tree=null;
        Object CHILD_COMPONENT75_tree=null;
        Object char_literal79_tree=null;
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleTokenStream stream_CHILD_COMPONENT=new RewriteRuleTokenStream(adaptor,"token CHILD_COMPONENT");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_vector=new RewriteRuleSubtreeStream(adaptor,"rule vector");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:150:4: ( CHILD_COMPONENT ident ident ';' -> ^( CHILD_COMPONENT ident ident ) | CHILD_COMPONENT ident ident vector ';' -> ^( CHILD_COMPONENT ident ident vector ) )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==CHILD_COMPONENT) ) {
                int LA14_1 = input.LA(2);

                if ( (LA14_1==Ident) ) {
                    int LA14_2 = input.LA(3);

                    if ( (LA14_2==Ident) ) {
                        int LA14_3 = input.LA(4);

                        if ( (LA14_3==72) ) {
                            alt14=1;
                        }
                        else if ( (LA14_3==78) ) {
                            alt14=2;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 14, 3, input);

                            throw nvae;

                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 14, 2, input);

                        throw nvae;

                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;

            }
            switch (alt14) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:150:6: CHILD_COMPONENT ident ident ';'
                    {
                    CHILD_COMPONENT71=(Token)match(input,CHILD_COMPONENT,FOLLOW_CHILD_COMPONENT_in_child_component_decl1211);  
                    stream_CHILD_COMPONENT.add(CHILD_COMPONENT71);


                    pushFollow(FOLLOW_ident_in_child_component_decl1213);
                    ident72=ident();

                    state._fsp--;

                    stream_ident.add(ident72.getTree());

                    pushFollow(FOLLOW_ident_in_child_component_decl1215);
                    ident73=ident();

                    state._fsp--;

                    stream_ident.add(ident73.getTree());

                    char_literal74=(Token)match(input,72,FOLLOW_72_in_child_component_decl1217);  
                    stream_72.add(char_literal74);


                    // AST REWRITE
                    // elements: CHILD_COMPONENT, ident, ident
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 150:38: -> ^( CHILD_COMPONENT ident ident )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:150:41: ^( CHILD_COMPONENT ident ident )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_CHILD_COMPONENT.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:151:9: CHILD_COMPONENT ident ident vector ';'
                    {
                    CHILD_COMPONENT75=(Token)match(input,CHILD_COMPONENT,FOLLOW_CHILD_COMPONENT_in_child_component_decl1238);  
                    stream_CHILD_COMPONENT.add(CHILD_COMPONENT75);


                    pushFollow(FOLLOW_ident_in_child_component_decl1240);
                    ident76=ident();

                    state._fsp--;

                    stream_ident.add(ident76.getTree());

                    pushFollow(FOLLOW_ident_in_child_component_decl1242);
                    ident77=ident();

                    state._fsp--;

                    stream_ident.add(ident77.getTree());

                    pushFollow(FOLLOW_vector_in_child_component_decl1244);
                    vector78=vector();

                    state._fsp--;

                    stream_vector.add(vector78.getTree());

                    char_literal79=(Token)match(input,72,FOLLOW_72_in_child_component_decl1246);  
                    stream_72.add(char_literal79);


                    // AST REWRITE
                    // elements: CHILD_COMPONENT, ident, ident, vector
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 151:48: -> ^( CHILD_COMPONENT ident ident vector )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:151:51: ^( CHILD_COMPONENT ident ident vector )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_CHILD_COMPONENT.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_vector.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "child_component_decl"


    public static class fail_mode_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "fail_mode_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:155:1: fail_mode_decl : FAIL_MODE ident ';' -> ^( FAIL_MODE ident ) ;
    public final RIIFParser.fail_mode_decl_return fail_mode_decl() throws RecognitionException {
        RIIFParser.fail_mode_decl_return retval = new RIIFParser.fail_mode_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token FAIL_MODE80=null;
        Token char_literal82=null;
        RIIFParser.ident_return ident81 =null;


        Object FAIL_MODE80_tree=null;
        Object char_literal82_tree=null;
        RewriteRuleTokenStream stream_FAIL_MODE=new RewriteRuleTokenStream(adaptor,"token FAIL_MODE");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:156:4: ( FAIL_MODE ident ';' -> ^( FAIL_MODE ident ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:156:6: FAIL_MODE ident ';'
            {
            FAIL_MODE80=(Token)match(input,FAIL_MODE,FOLLOW_FAIL_MODE_in_fail_mode_decl1273);  
            stream_FAIL_MODE.add(FAIL_MODE80);


            pushFollow(FOLLOW_ident_in_fail_mode_decl1275);
            ident81=ident();

            state._fsp--;

            stream_ident.add(ident81.getTree());

            char_literal82=(Token)match(input,72,FOLLOW_72_in_fail_mode_decl1277);  
            stream_72.add(char_literal82);


            // AST REWRITE
            // elements: FAIL_MODE, ident
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 157:7: -> ^( FAIL_MODE ident )
            {
                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:157:10: ^( FAIL_MODE ident )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                stream_FAIL_MODE.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_ident.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "fail_mode_decl"


    public static class state_decl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "state_decl"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:161:1: state_decl : ( special_state STATE ':' ident ';' -> ^( STATE ident special_state ) | STATE ':' ident ';' -> ^( STATE ident ) );
    public final RIIFParser.state_decl_return state_decl() throws RecognitionException {
        RIIFParser.state_decl_return retval = new RIIFParser.state_decl_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token STATE84=null;
        Token char_literal85=null;
        Token char_literal87=null;
        Token STATE88=null;
        Token char_literal89=null;
        Token char_literal91=null;
        RIIFParser.special_state_return special_state83 =null;

        RIIFParser.ident_return ident86 =null;

        RIIFParser.ident_return ident90 =null;


        Object STATE84_tree=null;
        Object char_literal85_tree=null;
        Object char_literal87_tree=null;
        Object STATE88_tree=null;
        Object char_literal89_tree=null;
        Object char_literal91_tree=null;
        RewriteRuleTokenStream stream_STATE=new RewriteRuleTokenStream(adaptor,"token STATE");
        RewriteRuleTokenStream stream_70=new RewriteRuleTokenStream(adaptor,"token 70");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_special_state=new RewriteRuleSubtreeStream(adaptor,"rule special_state");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:162:4: ( special_state STATE ':' ident ';' -> ^( STATE ident special_state ) | STATE ':' ident ';' -> ^( STATE ident ) )
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==INITIAL||LA15_0==TERMINAL) ) {
                alt15=1;
            }
            else if ( (LA15_0==STATE) ) {
                alt15=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;

            }
            switch (alt15) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:162:6: special_state STATE ':' ident ';'
                    {
                    pushFollow(FOLLOW_special_state_in_state_decl1307);
                    special_state83=special_state();

                    state._fsp--;

                    stream_special_state.add(special_state83.getTree());

                    STATE84=(Token)match(input,STATE,FOLLOW_STATE_in_state_decl1309);  
                    stream_STATE.add(STATE84);


                    char_literal85=(Token)match(input,70,FOLLOW_70_in_state_decl1311);  
                    stream_70.add(char_literal85);


                    pushFollow(FOLLOW_ident_in_state_decl1313);
                    ident86=ident();

                    state._fsp--;

                    stream_ident.add(ident86.getTree());

                    char_literal87=(Token)match(input,72,FOLLOW_72_in_state_decl1315);  
                    stream_72.add(char_literal87);


                    // AST REWRITE
                    // elements: ident, STATE, special_state
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 162:40: -> ^( STATE ident special_state )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:162:43: ^( STATE ident special_state )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_STATE.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_1, stream_special_state.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:163:9: STATE ':' ident ';'
                    {
                    STATE88=(Token)match(input,STATE,FOLLOW_STATE_in_state_decl1336);  
                    stream_STATE.add(STATE88);


                    char_literal89=(Token)match(input,70,FOLLOW_70_in_state_decl1338);  
                    stream_70.add(char_literal89);


                    pushFollow(FOLLOW_ident_in_state_decl1340);
                    ident90=ident();

                    state._fsp--;

                    stream_ident.add(ident90.getTree());

                    char_literal91=(Token)match(input,72,FOLLOW_72_in_state_decl1342);  
                    stream_72.add(char_literal91);


                    // AST REWRITE
                    // elements: STATE, ident
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 163:29: -> ^( STATE ident )
                    {
                        // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:163:32: ^( STATE ident )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        stream_STATE.nextNode()
                        , root_1);

                        adaptor.addChild(root_1, stream_ident.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "state_decl"


    public static class special_state_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "special_state"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:165:1: special_state : ( INITIAL | TERMINAL ) ;
    public final RIIFParser.special_state_return special_state() throws RecognitionException {
        RIIFParser.special_state_return retval = new RIIFParser.special_state_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set92=null;

        Object set92_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:166:5: ( ( INITIAL | TERMINAL ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:
            {
            root_0 = (Object)adaptor.nil();


            set92=(Token)input.LT(1);

            if ( input.LA(1)==INITIAL||input.LA(1)==TERMINAL ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set92)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "special_state"


    public static class assignment_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "assignment"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:171:1: assignment : ASSIGN ( ident | hier_ident | attr_ident ) ( vector )? '=' expression ';' -> ^( ASSIGN ( ident )* ( hier_ident )* ( attr_ident )* ( vector )? ^( ASSIGN expression ) ) ;
    public final RIIFParser.assignment_return assignment() throws RecognitionException {
        RIIFParser.assignment_return retval = new RIIFParser.assignment_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token ASSIGN93=null;
        Token char_literal98=null;
        Token char_literal100=null;
        RIIFParser.ident_return ident94 =null;

        RIIFParser.hier_ident_return hier_ident95 =null;

        RIIFParser.attr_ident_return attr_ident96 =null;

        RIIFParser.vector_return vector97 =null;

        RIIFParser.expression_return expression99 =null;


        Object ASSIGN93_tree=null;
        Object char_literal98_tree=null;
        Object char_literal100_tree=null;
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleTokenStream stream_74=new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_ident=new RewriteRuleSubtreeStream(adaptor,"rule ident");
        RewriteRuleSubtreeStream stream_hier_ident=new RewriteRuleSubtreeStream(adaptor,"rule hier_ident");
        RewriteRuleSubtreeStream stream_vector=new RewriteRuleSubtreeStream(adaptor,"rule vector");
        RewriteRuleSubtreeStream stream_attr_ident=new RewriteRuleSubtreeStream(adaptor,"rule attr_ident");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:4: ( ASSIGN ( ident | hier_ident | attr_ident ) ( vector )? '=' expression ';' -> ^( ASSIGN ( ident )* ( hier_ident )* ( attr_ident )* ( vector )? ^( ASSIGN expression ) ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:6: ASSIGN ( ident | hier_ident | attr_ident ) ( vector )? '=' expression ';'
            {
            ASSIGN93=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignment1390);  
            stream_ASSIGN.add(ASSIGN93);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:13: ( ident | hier_ident | attr_ident )
            int alt16=3;
            switch ( input.LA(1) ) {
            case Ident:
                {
                alt16=1;
                }
                break;
            case Hier_ident:
                {
                alt16=2;
                }
                break;
            case Attr_ident:
                {
                alt16=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;

            }

            switch (alt16) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:15: ident
                    {
                    pushFollow(FOLLOW_ident_in_assignment1394);
                    ident94=ident();

                    state._fsp--;

                    stream_ident.add(ident94.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:23: hier_ident
                    {
                    pushFollow(FOLLOW_hier_ident_in_assignment1398);
                    hier_ident95=hier_ident();

                    state._fsp--;

                    stream_hier_ident.add(hier_ident95.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:36: attr_ident
                    {
                    pushFollow(FOLLOW_attr_ident_in_assignment1402);
                    attr_ident96=attr_ident();

                    state._fsp--;

                    stream_attr_ident.add(attr_ident96.getTree());

                    }
                    break;

            }


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:49: ( vector )?
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==78) ) {
                alt17=1;
            }
            switch (alt17) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:172:49: vector
                    {
                    pushFollow(FOLLOW_vector_in_assignment1406);
                    vector97=vector();

                    state._fsp--;

                    stream_vector.add(vector97.getTree());

                    }
                    break;

            }


            char_literal98=(Token)match(input,74,FOLLOW_74_in_assignment1410);  
            stream_74.add(char_literal98);


            pushFollow(FOLLOW_expression_in_assignment1412);
            expression99=expression();

            state._fsp--;

            stream_expression.add(expression99.getTree());

            char_literal100=(Token)match(input,72,FOLLOW_72_in_assignment1414);  
            stream_72.add(char_literal100);


            // AST REWRITE
            // elements: ASSIGN, vector, ASSIGN, expression, attr_ident, hier_ident, ident
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 173:5: -> ^( ASSIGN ( ident )* ( hier_ident )* ( attr_ident )* ( vector )? ^( ASSIGN expression ) )
            {
                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:173:8: ^( ASSIGN ( ident )* ( hier_ident )* ( attr_ident )* ( vector )? ^( ASSIGN expression ) )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                stream_ASSIGN.nextNode()
                , root_1);

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:173:18: ( ident )*
                while ( stream_ident.hasNext() ) {
                    adaptor.addChild(root_1, stream_ident.nextTree());

                }
                stream_ident.reset();

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:173:25: ( hier_ident )*
                while ( stream_hier_ident.hasNext() ) {
                    adaptor.addChild(root_1, stream_hier_ident.nextTree());

                }
                stream_hier_ident.reset();

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:173:37: ( attr_ident )*
                while ( stream_attr_ident.hasNext() ) {
                    adaptor.addChild(root_1, stream_attr_ident.nextTree());

                }
                stream_attr_ident.reset();

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:173:49: ( vector )?
                if ( stream_vector.hasNext() ) {
                    adaptor.addChild(root_1, stream_vector.nextTree());

                }
                stream_vector.reset();

                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:173:59: ^( ASSIGN expression )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot(
                stream_ASSIGN.nextNode()
                , root_2);

                adaptor.addChild(root_2, stream_expression.nextTree());

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "assignment"


    public static class assertion_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "assertion"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:177:1: assertion : ASSERT ( attr_ident ) relationalOp expression ';' -> ^( ASSERT attr_ident relationalOp expression ) ;
    public final RIIFParser.assertion_return assertion() throws RecognitionException {
        RIIFParser.assertion_return retval = new RIIFParser.assertion_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token ASSERT101=null;
        Token char_literal105=null;
        RIIFParser.attr_ident_return attr_ident102 =null;

        RIIFParser.relationalOp_return relationalOp103 =null;

        RIIFParser.expression_return expression104 =null;


        Object ASSERT101_tree=null;
        Object char_literal105_tree=null;
        RewriteRuleTokenStream stream_ASSERT=new RewriteRuleTokenStream(adaptor,"token ASSERT");
        RewriteRuleTokenStream stream_72=new RewriteRuleTokenStream(adaptor,"token 72");
        RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_relationalOp=new RewriteRuleSubtreeStream(adaptor,"rule relationalOp");
        RewriteRuleSubtreeStream stream_attr_ident=new RewriteRuleSubtreeStream(adaptor,"rule attr_ident");
        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:178:4: ( ASSERT ( attr_ident ) relationalOp expression ';' -> ^( ASSERT attr_ident relationalOp expression ) )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:178:6: ASSERT ( attr_ident ) relationalOp expression ';'
            {
            ASSERT101=(Token)match(input,ASSERT,FOLLOW_ASSERT_in_assertion1463);  
            stream_ASSERT.add(ASSERT101);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:178:13: ( attr_ident )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:178:15: attr_ident
            {
            pushFollow(FOLLOW_attr_ident_in_assertion1467);
            attr_ident102=attr_ident();

            state._fsp--;

            stream_attr_ident.add(attr_ident102.getTree());

            }


            pushFollow(FOLLOW_relationalOp_in_assertion1471);
            relationalOp103=relationalOp();

            state._fsp--;

            stream_relationalOp.add(relationalOp103.getTree());

            pushFollow(FOLLOW_expression_in_assertion1473);
            expression104=expression();

            state._fsp--;

            stream_expression.add(expression104.getTree());

            char_literal105=(Token)match(input,72,FOLLOW_72_in_assertion1475);  
            stream_72.add(char_literal105);


            // AST REWRITE
            // elements: ASSERT, expression, attr_ident, relationalOp
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 179:6: -> ^( ASSERT attr_ident relationalOp expression )
            {
                // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:179:9: ^( ASSERT attr_ident relationalOp expression )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                stream_ASSERT.nextNode()
                , root_1);

                adaptor.addChild(root_1, stream_attr_ident.nextTree());

                adaptor.addChild(root_1, stream_relationalOp.nextTree());

                adaptor.addChild(root_1, stream_expression.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "assertion"


    public static class primitive_type_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "primitive_type"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:182:1: primitive_type : ( TYPE_FLOAT | TYPE_INTEGER | TYPE_STRING );
    public final RIIFParser.primitive_type_return primitive_type() throws RecognitionException {
        RIIFParser.primitive_type_return retval = new RIIFParser.primitive_type_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set106=null;

        Object set106_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:183:4: ( TYPE_FLOAT | TYPE_INTEGER | TYPE_STRING )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:
            {
            root_0 = (Object)adaptor.nil();


            set106=(Token)input.LT(1);

            if ( (input.LA(1) >= TYPE_FLOAT && input.LA(1) <= TYPE_STRING) ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set106)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "primitive_type"


    public static class enum_type_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enum_type"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:185:1: enum_type : TYPE_ENUM '{' ident ( ',' ident )* '}' ;
    public final RIIFParser.enum_type_return enum_type() throws RecognitionException {
        RIIFParser.enum_type_return retval = new RIIFParser.enum_type_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token TYPE_ENUM107=null;
        Token char_literal108=null;
        Token char_literal110=null;
        Token char_literal112=null;
        RIIFParser.ident_return ident109 =null;

        RIIFParser.ident_return ident111 =null;


        Object TYPE_ENUM107_tree=null;
        Object char_literal108_tree=null;
        Object char_literal110_tree=null;
        Object char_literal112_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:186:4: ( TYPE_ENUM '{' ident ( ',' ident )* '}' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:186:6: TYPE_ENUM '{' ident ( ',' ident )* '}'
            {
            root_0 = (Object)adaptor.nil();


            TYPE_ENUM107=(Token)match(input,TYPE_ENUM,FOLLOW_TYPE_ENUM_in_enum_type1527); 
            TYPE_ENUM107_tree = 
            (Object)adaptor.create(TYPE_ENUM107)
            ;
            adaptor.addChild(root_0, TYPE_ENUM107_tree);


            char_literal108=(Token)match(input,81,FOLLOW_81_in_enum_type1529); 
            char_literal108_tree = 
            (Object)adaptor.create(char_literal108)
            ;
            adaptor.addChild(root_0, char_literal108_tree);


            pushFollow(FOLLOW_ident_in_enum_type1531);
            ident109=ident();

            state._fsp--;

            adaptor.addChild(root_0, ident109.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:186:26: ( ',' ident )*
            loop18:
            do {
                int alt18=2;
                int LA18_0 = input.LA(1);

                if ( (LA18_0==67) ) {
                    alt18=1;
                }


                switch (alt18) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:186:28: ',' ident
            	    {
            	    char_literal110=(Token)match(input,67,FOLLOW_67_in_enum_type1535); 
            	    char_literal110_tree = 
            	    (Object)adaptor.create(char_literal110)
            	    ;
            	    adaptor.addChild(root_0, char_literal110_tree);


            	    pushFollow(FOLLOW_ident_in_enum_type1537);
            	    ident111=ident();

            	    state._fsp--;

            	    adaptor.addChild(root_0, ident111.getTree());

            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);


            char_literal112=(Token)match(input,84,FOLLOW_84_in_enum_type1543); 
            char_literal112_tree = 
            (Object)adaptor.create(char_literal112)
            ;
            adaptor.addChild(root_0, char_literal112_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "enum_type"


    public static class user_type_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "user_type"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:188:1: user_type : Ident ;
    public final RIIFParser.user_type_return user_type() throws RecognitionException {
        RIIFParser.user_type_return retval = new RIIFParser.user_type_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token Ident113=null;

        Object Ident113_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:189:5: ( Ident )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:189:7: Ident
            {
            root_0 = (Object)adaptor.nil();


            Ident113=(Token)match(input,Ident,FOLLOW_Ident_in_user_type1556); 
            Ident113_tree = 
            (Object)adaptor.create(Ident113)
            ;
            adaptor.addChild(root_0, Ident113_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "user_type"


    public static class complex_type_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "complex_type"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:191:1: complex_type : ( primitive_type | enum_type | user_type );
    public final RIIFParser.complex_type_return complex_type() throws RecognitionException {
        RIIFParser.complex_type_return retval = new RIIFParser.complex_type_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.primitive_type_return primitive_type114 =null;

        RIIFParser.enum_type_return enum_type115 =null;

        RIIFParser.user_type_return user_type116 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:192:5: ( primitive_type | enum_type | user_type )
            int alt19=3;
            switch ( input.LA(1) ) {
            case TYPE_FLOAT:
            case TYPE_INTEGER:
            case TYPE_STRING:
                {
                alt19=1;
                }
                break;
            case TYPE_ENUM:
                {
                alt19=2;
                }
                break;
            case Ident:
                {
                alt19=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                throw nvae;

            }

            switch (alt19) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:192:7: primitive_type
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_primitive_type_in_complex_type1569);
                    primitive_type114=primitive_type();

                    state._fsp--;

                    adaptor.addChild(root_0, primitive_type114.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:192:24: enum_type
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_enum_type_in_complex_type1573);
                    enum_type115=enum_type();

                    state._fsp--;

                    adaptor.addChild(root_0, enum_type115.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:192:36: user_type
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_user_type_in_complex_type1577);
                    user_type116=user_type();

                    state._fsp--;

                    adaptor.addChild(root_0, user_type116.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "complex_type"


    public static class units_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "units"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:196:1: units : ( UNIT_VOLTS | UNIT_FITS | UNIT_CDEGREES );
    public final RIIFParser.units_return units() throws RecognitionException {
        RIIFParser.units_return retval = new RIIFParser.units_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set117=null;

        Object set117_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:197:4: ( UNIT_VOLTS | UNIT_FITS | UNIT_CDEGREES )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:
            {
            root_0 = (Object)adaptor.nil();


            set117=(Token)input.LT(1);

            if ( (input.LA(1) >= UNIT_CDEGREES && input.LA(1) <= UNIT_VOLTS) ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set117)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "units"


    public static class literal_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "literal"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:251:1: literal : ( StringLiteral | integerLiteral | FloatingPointLiteral | units );
    public final RIIFParser.literal_return literal() throws RecognitionException {
        RIIFParser.literal_return retval = new RIIFParser.literal_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token StringLiteral118=null;
        Token FloatingPointLiteral120=null;
        RIIFParser.integerLiteral_return integerLiteral119 =null;

        RIIFParser.units_return units121 =null;


        Object StringLiteral118_tree=null;
        Object FloatingPointLiteral120_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:252:4: ( StringLiteral | integerLiteral | FloatingPointLiteral | units )
            int alt20=4;
            switch ( input.LA(1) ) {
            case StringLiteral:
                {
                alt20=1;
                }
                break;
            case DecimalLiteral:
                {
                alt20=2;
                }
                break;
            case FloatingPointLiteral:
                {
                alt20=3;
                }
                break;
            case UNIT_CDEGREES:
            case UNIT_FITS:
            case UNIT_VOLTS:
                {
                alt20=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;

            }

            switch (alt20) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:252:6: StringLiteral
                    {
                    root_0 = (Object)adaptor.nil();


                    StringLiteral118=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_literal2040); 
                    StringLiteral118_tree = 
                    (Object)adaptor.create(StringLiteral118)
                    ;
                    adaptor.addChild(root_0, StringLiteral118_tree);


                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:253:6: integerLiteral
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_integerLiteral_in_literal2047);
                    integerLiteral119=integerLiteral();

                    state._fsp--;

                    adaptor.addChild(root_0, integerLiteral119.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:254:6: FloatingPointLiteral
                    {
                    root_0 = (Object)adaptor.nil();


                    FloatingPointLiteral120=(Token)match(input,FloatingPointLiteral,FOLLOW_FloatingPointLiteral_in_literal2054); 
                    FloatingPointLiteral120_tree = 
                    (Object)adaptor.create(FloatingPointLiteral120)
                    ;
                    adaptor.addChild(root_0, FloatingPointLiteral120_tree);


                    }
                    break;
                case 4 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:255:6: units
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_units_in_literal2061);
                    units121=units();

                    state._fsp--;

                    adaptor.addChild(root_0, units121.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "literal"


    public static class integerLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "integerLiteral"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:257:1: integerLiteral : DecimalLiteral ;
    public final RIIFParser.integerLiteral_return integerLiteral() throws RecognitionException {
        RIIFParser.integerLiteral_return retval = new RIIFParser.integerLiteral_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token DecimalLiteral122=null;

        Object DecimalLiteral122_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:258:4: ( DecimalLiteral )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:258:6: DecimalLiteral
            {
            root_0 = (Object)adaptor.nil();


            DecimalLiteral122=(Token)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_integerLiteral2073); 
            DecimalLiteral122_tree = 
            (Object)adaptor.create(DecimalLiteral122)
            ;
            adaptor.addChild(root_0, DecimalLiteral122_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "integerLiteral"


    public static class unitLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "unitLiteral"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:260:1: unitLiteral : ( integerLiteral | FloatingPointLiteral ) '_' units ;
    public final RIIFParser.unitLiteral_return unitLiteral() throws RecognitionException {
        RIIFParser.unitLiteral_return retval = new RIIFParser.unitLiteral_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token FloatingPointLiteral124=null;
        Token char_literal125=null;
        RIIFParser.integerLiteral_return integerLiteral123 =null;

        RIIFParser.units_return units126 =null;


        Object FloatingPointLiteral124_tree=null;
        Object char_literal125_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:261:4: ( ( integerLiteral | FloatingPointLiteral ) '_' units )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:261:6: ( integerLiteral | FloatingPointLiteral ) '_' units
            {
            root_0 = (Object)adaptor.nil();


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:261:6: ( integerLiteral | FloatingPointLiteral )
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0==DecimalLiteral) ) {
                alt21=1;
            }
            else if ( (LA21_0==FloatingPointLiteral) ) {
                alt21=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;

            }
            switch (alt21) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:261:7: integerLiteral
                    {
                    pushFollow(FOLLOW_integerLiteral_in_unitLiteral2085);
                    integerLiteral123=integerLiteral();

                    state._fsp--;

                    adaptor.addChild(root_0, integerLiteral123.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:261:22: FloatingPointLiteral
                    {
                    FloatingPointLiteral124=(Token)match(input,FloatingPointLiteral,FOLLOW_FloatingPointLiteral_in_unitLiteral2087); 
                    FloatingPointLiteral124_tree = 
                    (Object)adaptor.create(FloatingPointLiteral124)
                    ;
                    adaptor.addChild(root_0, FloatingPointLiteral124_tree);


                    }
                    break;

            }


            char_literal125=(Token)match(input,UNDERSCORE,FOLLOW_UNDERSCORE_in_unitLiteral2090); 
            char_literal125_tree = 
            (Object)adaptor.create(char_literal125)
            ;
            adaptor.addChild(root_0, char_literal125_tree);


            pushFollow(FOLLOW_units_in_unitLiteral2092);
            units126=units();

            state._fsp--;

            adaptor.addChild(root_0, units126.getTree());

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "unitLiteral"


    public static class primary_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "primary"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:269:1: primary : ( parExpression | envCall | timeCall | funcCall | literal | ident | hier_ident | attr_ident );
    public final RIIFParser.primary_return primary() throws RecognitionException {
        RIIFParser.primary_return retval = new RIIFParser.primary_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.parExpression_return parExpression127 =null;

        RIIFParser.envCall_return envCall128 =null;

        RIIFParser.timeCall_return timeCall129 =null;

        RIIFParser.funcCall_return funcCall130 =null;

        RIIFParser.literal_return literal131 =null;

        RIIFParser.ident_return ident132 =null;

        RIIFParser.hier_ident_return hier_ident133 =null;

        RIIFParser.attr_ident_return attr_ident134 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:270:4: ( parExpression | envCall | timeCall | funcCall | literal | ident | hier_ident | attr_ident )
            int alt22=8;
            switch ( input.LA(1) ) {
            case 63:
                {
                alt22=1;
                }
                break;
            case GET_VALUE:
                {
                alt22=2;
                }
                break;
            case GET_TRANSITION:
            case GET_TRANSITION_TIME:
                {
                alt22=3;
                }
                break;
            case EXPRESS_TIME:
            case FUNC_AGG_SINGLE:
            case FUNC_EXP:
            case FUNC_GT_N_FAIL:
            case FUNC_LOG:
            case POW:
                {
                alt22=4;
                }
                break;
            case DecimalLiteral:
            case FloatingPointLiteral:
            case StringLiteral:
            case UNIT_CDEGREES:
            case UNIT_FITS:
            case UNIT_VOLTS:
                {
                alt22=5;
                }
                break;
            case Ident:
                {
                alt22=6;
                }
                break;
            case Hier_ident:
                {
                alt22=7;
                }
                break;
            case Attr_ident:
                {
                alt22=8;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;

            }

            switch (alt22) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:270:8: parExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_parExpression_in_primary2123);
                    parExpression127=parExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, parExpression127.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:271:8: envCall
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_envCall_in_primary2132);
                    envCall128=envCall();

                    state._fsp--;

                    adaptor.addChild(root_0, envCall128.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:272:8: timeCall
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_timeCall_in_primary2141);
                    timeCall129=timeCall();

                    state._fsp--;

                    adaptor.addChild(root_0, timeCall129.getTree());

                    }
                    break;
                case 4 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:273:8: funcCall
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_funcCall_in_primary2150);
                    funcCall130=funcCall();

                    state._fsp--;

                    adaptor.addChild(root_0, funcCall130.getTree());

                    }
                    break;
                case 5 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:274:8: literal
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_literal_in_primary2159);
                    literal131=literal();

                    state._fsp--;

                    adaptor.addChild(root_0, literal131.getTree());

                    }
                    break;
                case 6 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:275:8: ident
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_ident_in_primary2168);
                    ident132=ident();

                    state._fsp--;

                    adaptor.addChild(root_0, ident132.getTree());

                    }
                    break;
                case 7 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:276:8: hier_ident
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_hier_ident_in_primary2177);
                    hier_ident133=hier_ident();

                    state._fsp--;

                    adaptor.addChild(root_0, hier_ident133.getTree());

                    }
                    break;
                case 8 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:277:8: attr_ident
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_attr_ident_in_primary2186);
                    attr_ident134=attr_ident();

                    state._fsp--;

                    adaptor.addChild(root_0, attr_ident134.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "primary"


    public static class envCall_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "envCall"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:279:1: envCall : envFunction '(' funcArg ( ',' funcArg )? ')' ;
    public final RIIFParser.envCall_return envCall() throws RecognitionException {
        RIIFParser.envCall_return retval = new RIIFParser.envCall_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal136=null;
        Token char_literal138=null;
        Token char_literal140=null;
        RIIFParser.envFunction_return envFunction135 =null;

        RIIFParser.funcArg_return funcArg137 =null;

        RIIFParser.funcArg_return funcArg139 =null;


        Object char_literal136_tree=null;
        Object char_literal138_tree=null;
        Object char_literal140_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:280:5: ( envFunction '(' funcArg ( ',' funcArg )? ')' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:280:7: envFunction '(' funcArg ( ',' funcArg )? ')'
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_envFunction_in_envCall2198);
            envFunction135=envFunction();

            state._fsp--;

            adaptor.addChild(root_0, envFunction135.getTree());

            char_literal136=(Token)match(input,63,FOLLOW_63_in_envCall2200); 
            char_literal136_tree = 
            (Object)adaptor.create(char_literal136)
            ;
            adaptor.addChild(root_0, char_literal136_tree);


            pushFollow(FOLLOW_funcArg_in_envCall2202);
            funcArg137=funcArg();

            state._fsp--;

            adaptor.addChild(root_0, funcArg137.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:280:31: ( ',' funcArg )?
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==67) ) {
                alt23=1;
            }
            switch (alt23) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:280:33: ',' funcArg
                    {
                    char_literal138=(Token)match(input,67,FOLLOW_67_in_envCall2206); 
                    char_literal138_tree = 
                    (Object)adaptor.create(char_literal138)
                    ;
                    adaptor.addChild(root_0, char_literal138_tree);


                    pushFollow(FOLLOW_funcArg_in_envCall2208);
                    funcArg139=funcArg();

                    state._fsp--;

                    adaptor.addChild(root_0, funcArg139.getTree());

                    }
                    break;

            }


            char_literal140=(Token)match(input,64,FOLLOW_64_in_envCall2214); 
            char_literal140_tree = 
            (Object)adaptor.create(char_literal140)
            ;
            adaptor.addChild(root_0, char_literal140_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "envCall"


    public static class envFunction_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "envFunction"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:283:1: envFunction : GET_VALUE ;
    public final RIIFParser.envFunction_return envFunction() throws RecognitionException {
        RIIFParser.envFunction_return retval = new RIIFParser.envFunction_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token GET_VALUE141=null;

        Object GET_VALUE141_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:284:2: ( GET_VALUE )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:284:4: GET_VALUE
            {
            root_0 = (Object)adaptor.nil();


            GET_VALUE141=(Token)match(input,GET_VALUE,FOLLOW_GET_VALUE_in_envFunction2225); 
            GET_VALUE141_tree = 
            (Object)adaptor.create(GET_VALUE141)
            ;
            adaptor.addChild(root_0, GET_VALUE141_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "envFunction"


    public static class timeCall_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "timeCall"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:287:1: timeCall : timeFunction '(' funcArg ( ',' funcArg )? ')' ;
    public final RIIFParser.timeCall_return timeCall() throws RecognitionException {
        RIIFParser.timeCall_return retval = new RIIFParser.timeCall_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal143=null;
        Token char_literal145=null;
        Token char_literal147=null;
        RIIFParser.timeFunction_return timeFunction142 =null;

        RIIFParser.funcArg_return funcArg144 =null;

        RIIFParser.funcArg_return funcArg146 =null;


        Object char_literal143_tree=null;
        Object char_literal145_tree=null;
        Object char_literal147_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:288:5: ( timeFunction '(' funcArg ( ',' funcArg )? ')' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:288:7: timeFunction '(' funcArg ( ',' funcArg )? ')'
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_timeFunction_in_timeCall2239);
            timeFunction142=timeFunction();

            state._fsp--;

            adaptor.addChild(root_0, timeFunction142.getTree());

            char_literal143=(Token)match(input,63,FOLLOW_63_in_timeCall2241); 
            char_literal143_tree = 
            (Object)adaptor.create(char_literal143)
            ;
            adaptor.addChild(root_0, char_literal143_tree);


            pushFollow(FOLLOW_funcArg_in_timeCall2243);
            funcArg144=funcArg();

            state._fsp--;

            adaptor.addChild(root_0, funcArg144.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:288:32: ( ',' funcArg )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0==67) ) {
                alt24=1;
            }
            switch (alt24) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:288:34: ',' funcArg
                    {
                    char_literal145=(Token)match(input,67,FOLLOW_67_in_timeCall2247); 
                    char_literal145_tree = 
                    (Object)adaptor.create(char_literal145)
                    ;
                    adaptor.addChild(root_0, char_literal145_tree);


                    pushFollow(FOLLOW_funcArg_in_timeCall2249);
                    funcArg146=funcArg();

                    state._fsp--;

                    adaptor.addChild(root_0, funcArg146.getTree());

                    }
                    break;

            }


            char_literal147=(Token)match(input,64,FOLLOW_64_in_timeCall2255); 
            char_literal147_tree = 
            (Object)adaptor.create(char_literal147)
            ;
            adaptor.addChild(root_0, char_literal147_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "timeCall"


    public static class timeFunction_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "timeFunction"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:291:1: timeFunction : ( GET_TRANSITION | GET_TRANSITION_TIME );
    public final RIIFParser.timeFunction_return timeFunction() throws RecognitionException {
        RIIFParser.timeFunction_return retval = new RIIFParser.timeFunction_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set148=null;

        Object set148_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:292:2: ( GET_TRANSITION | GET_TRANSITION_TIME )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:
            {
            root_0 = (Object)adaptor.nil();


            set148=(Token)input.LT(1);

            if ( (input.LA(1) >= GET_TRANSITION && input.LA(1) <= GET_TRANSITION_TIME) ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set148)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "timeFunction"


    public static class ident_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "ident"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:297:1: ident : Ident ;
    public final RIIFParser.ident_return ident() throws RecognitionException {
        RIIFParser.ident_return retval = new RIIFParser.ident_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token Ident149=null;

        Object Ident149_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:297:7: ( Ident )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:297:9: Ident
            {
            root_0 = (Object)adaptor.nil();


            Ident149=(Token)match(input,Ident,FOLLOW_Ident_in_ident2311); 
            Ident149_tree = 
            (Object)adaptor.create(Ident149)
            ;
            adaptor.addChild(root_0, Ident149_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "ident"


    public static class hier_ident_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "hier_ident"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:301:1: hier_ident : Hier_ident ;
    public final RIIFParser.hier_ident_return hier_ident() throws RecognitionException {
        RIIFParser.hier_ident_return retval = new RIIFParser.hier_ident_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token Hier_ident150=null;

        Object Hier_ident150_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:301:16: ( Hier_ident )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:301:18: Hier_ident
            {
            root_0 = (Object)adaptor.nil();


            Hier_ident150=(Token)match(input,Hier_ident,FOLLOW_Hier_ident_in_hier_ident2346); 
            Hier_ident150_tree = 
            (Object)adaptor.create(Hier_ident150)
            ;
            adaptor.addChild(root_0, Hier_ident150_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "hier_ident"


    public static class attr_ident_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "attr_ident"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:305:1: attr_ident : Attr_ident ;
    public final RIIFParser.attr_ident_return attr_ident() throws RecognitionException {
        RIIFParser.attr_ident_return retval = new RIIFParser.attr_ident_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token Attr_ident151=null;

        Object Attr_ident151_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:305:16: ( Attr_ident )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:305:18: Attr_ident
            {
            root_0 = (Object)adaptor.nil();


            Attr_ident151=(Token)match(input,Attr_ident,FOLLOW_Attr_ident_in_attr_ident2382); 
            Attr_ident151_tree = 
            (Object)adaptor.create(Attr_ident151)
            ;
            adaptor.addChild(root_0, Attr_ident151_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "attr_ident"


    public static class vector_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "vector"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:1: vector : '[' ( DecimalLiteral | ident ) ':' ( DecimalLiteral | ident ) ']' ;
    public final RIIFParser.vector_return vector() throws RecognitionException {
        RIIFParser.vector_return retval = new RIIFParser.vector_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal152=null;
        Token DecimalLiteral153=null;
        Token char_literal155=null;
        Token DecimalLiteral156=null;
        Token char_literal158=null;
        RIIFParser.ident_return ident154 =null;

        RIIFParser.ident_return ident157 =null;


        Object char_literal152_tree=null;
        Object DecimalLiteral153_tree=null;
        Object char_literal155_tree=null;
        Object DecimalLiteral156_tree=null;
        Object char_literal158_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:20: ( '[' ( DecimalLiteral | ident ) ':' ( DecimalLiteral | ident ) ']' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:22: '[' ( DecimalLiteral | ident ) ':' ( DecimalLiteral | ident ) ']'
            {
            root_0 = (Object)adaptor.nil();


            char_literal152=(Token)match(input,78,FOLLOW_78_in_vector2403); 
            char_literal152_tree = 
            (Object)adaptor.create(char_literal152)
            ;
            adaptor.addChild(root_0, char_literal152_tree);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:26: ( DecimalLiteral | ident )
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==DecimalLiteral) ) {
                alt25=1;
            }
            else if ( (LA25_0==Ident) ) {
                alt25=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;

            }
            switch (alt25) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:27: DecimalLiteral
                    {
                    DecimalLiteral153=(Token)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_vector2406); 
                    DecimalLiteral153_tree = 
                    (Object)adaptor.create(DecimalLiteral153)
                    ;
                    adaptor.addChild(root_0, DecimalLiteral153_tree);


                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:42: ident
                    {
                    pushFollow(FOLLOW_ident_in_vector2408);
                    ident154=ident();

                    state._fsp--;

                    adaptor.addChild(root_0, ident154.getTree());

                    }
                    break;

            }


            char_literal155=(Token)match(input,70,FOLLOW_70_in_vector2411); 
            char_literal155_tree = 
            (Object)adaptor.create(char_literal155)
            ;
            adaptor.addChild(root_0, char_literal155_tree);


            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:53: ( DecimalLiteral | ident )
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==DecimalLiteral) ) {
                alt26=1;
            }
            else if ( (LA26_0==Ident) ) {
                alt26=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;

            }
            switch (alt26) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:54: DecimalLiteral
                    {
                    DecimalLiteral156=(Token)match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_vector2414); 
                    DecimalLiteral156_tree = 
                    (Object)adaptor.create(DecimalLiteral156)
                    ;
                    adaptor.addChild(root_0, DecimalLiteral156_tree);


                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:307:69: ident
                    {
                    pushFollow(FOLLOW_ident_in_vector2416);
                    ident157=ident();

                    state._fsp--;

                    adaptor.addChild(root_0, ident157.getTree());

                    }
                    break;

            }


            char_literal158=(Token)match(input,79,FOLLOW_79_in_vector2419); 
            char_literal158_tree = 
            (Object)adaptor.create(char_literal158)
            ;
            adaptor.addChild(root_0, char_literal158_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "vector"


    public static class parExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "parExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:310:1: parExpression : '(' expression ')' ;
    public final RIIFParser.parExpression_return parExpression() throws RecognitionException {
        RIIFParser.parExpression_return retval = new RIIFParser.parExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal159=null;
        Token char_literal161=null;
        RIIFParser.expression_return expression160 =null;


        Object char_literal159_tree=null;
        Object char_literal161_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:311:5: ( '(' expression ')' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:311:9: '(' expression ')'
            {
            root_0 = (Object)adaptor.nil();


            char_literal159=(Token)match(input,63,FOLLOW_63_in_parExpression2435); 
            char_literal159_tree = 
            (Object)adaptor.create(char_literal159)
            ;
            adaptor.addChild(root_0, char_literal159_tree);


            pushFollow(FOLLOW_expression_in_parExpression2437);
            expression160=expression();

            state._fsp--;

            adaptor.addChild(root_0, expression160.getTree());

            char_literal161=(Token)match(input,64,FOLLOW_64_in_parExpression2439); 
            char_literal161_tree = 
            (Object)adaptor.create(char_literal161)
            ;
            adaptor.addChild(root_0, char_literal161_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "parExpression"


    public static class funcArg_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "funcArg"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:314:1: funcArg : ( ( ident | hier_ident | attr_ident ) vector | expression );
    public final RIIFParser.funcArg_return funcArg() throws RecognitionException {
        RIIFParser.funcArg_return retval = new RIIFParser.funcArg_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.ident_return ident162 =null;

        RIIFParser.hier_ident_return hier_ident163 =null;

        RIIFParser.attr_ident_return attr_ident164 =null;

        RIIFParser.vector_return vector165 =null;

        RIIFParser.expression_return expression166 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:315:5: ( ( ident | hier_ident | attr_ident ) vector | expression )
            int alt28=2;
            switch ( input.LA(1) ) {
            case Ident:
                {
                int LA28_1 = input.LA(2);

                if ( (LA28_1==78) ) {
                    alt28=1;
                }
                else if ( ((LA28_1 >= 59 && LA28_1 <= 62)||(LA28_1 >= 64 && LA28_1 <= 69)||LA28_1==73||(LA28_1 >= 75 && LA28_1 <= 77)||LA28_1==80||(LA28_1 >= 82 && LA28_1 <= 83)) ) {
                    alt28=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 1, input);

                    throw nvae;

                }
                }
                break;
            case Hier_ident:
                {
                int LA28_2 = input.LA(2);

                if ( (LA28_2==78) ) {
                    alt28=1;
                }
                else if ( ((LA28_2 >= 59 && LA28_2 <= 62)||(LA28_2 >= 64 && LA28_2 <= 69)||LA28_2==73||(LA28_2 >= 75 && LA28_2 <= 77)||LA28_2==80||(LA28_2 >= 82 && LA28_2 <= 83)) ) {
                    alt28=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 2, input);

                    throw nvae;

                }
                }
                break;
            case Attr_ident:
                {
                int LA28_3 = input.LA(2);

                if ( (LA28_3==78) ) {
                    alt28=1;
                }
                else if ( ((LA28_3 >= 59 && LA28_3 <= 62)||(LA28_3 >= 64 && LA28_3 <= 69)||LA28_3==73||(LA28_3 >= 75 && LA28_3 <= 77)||LA28_3==80||(LA28_3 >= 82 && LA28_3 <= 83)) ) {
                    alt28=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 3, input);

                    throw nvae;

                }
                }
                break;
            case DecimalLiteral:
            case EXPRESS_TIME:
            case FUNC_AGG_SINGLE:
            case FUNC_EXP:
            case FUNC_GT_N_FAIL:
            case FUNC_LOG:
            case FloatingPointLiteral:
            case GET_TRANSITION:
            case GET_TRANSITION_TIME:
            case GET_VALUE:
            case POW:
            case StringLiteral:
            case UNIT_CDEGREES:
            case UNIT_FITS:
            case UNIT_VOLTS:
            case 58:
            case 63:
            case 66:
            case 68:
            case 85:
                {
                alt28=2;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                throw nvae;

            }

            switch (alt28) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:315:7: ( ident | hier_ident | attr_ident ) vector
                    {
                    root_0 = (Object)adaptor.nil();


                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:315:7: ( ident | hier_ident | attr_ident )
                    int alt27=3;
                    switch ( input.LA(1) ) {
                    case Ident:
                        {
                        alt27=1;
                        }
                        break;
                    case Hier_ident:
                        {
                        alt27=2;
                        }
                        break;
                    case Attr_ident:
                        {
                        alt27=3;
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 27, 0, input);

                        throw nvae;

                    }

                    switch (alt27) {
                        case 1 :
                            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:315:9: ident
                            {
                            pushFollow(FOLLOW_ident_in_funcArg2461);
                            ident162=ident();

                            state._fsp--;

                            adaptor.addChild(root_0, ident162.getTree());

                            }
                            break;
                        case 2 :
                            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:315:17: hier_ident
                            {
                            pushFollow(FOLLOW_hier_ident_in_funcArg2465);
                            hier_ident163=hier_ident();

                            state._fsp--;

                            adaptor.addChild(root_0, hier_ident163.getTree());

                            }
                            break;
                        case 3 :
                            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:315:30: attr_ident
                            {
                            pushFollow(FOLLOW_attr_ident_in_funcArg2469);
                            attr_ident164=attr_ident();

                            state._fsp--;

                            adaptor.addChild(root_0, attr_ident164.getTree());

                            }
                            break;

                    }


                    pushFollow(FOLLOW_vector_in_funcArg2473);
                    vector165=vector();

                    state._fsp--;

                    adaptor.addChild(root_0, vector165.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:316:9: expression
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_expression_in_funcArg2485);
                    expression166=expression();

                    state._fsp--;

                    adaptor.addChild(root_0, expression166.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "funcArg"


    public static class funcCall_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "funcCall"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:318:1: funcCall : funcname '(' funcArg ( ',' funcArg )? ')' ;
    public final RIIFParser.funcCall_return funcCall() throws RecognitionException {
        RIIFParser.funcCall_return retval = new RIIFParser.funcCall_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal168=null;
        Token char_literal170=null;
        Token char_literal172=null;
        RIIFParser.funcname_return funcname167 =null;

        RIIFParser.funcArg_return funcArg169 =null;

        RIIFParser.funcArg_return funcArg171 =null;


        Object char_literal168_tree=null;
        Object char_literal170_tree=null;
        Object char_literal172_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:319:5: ( funcname '(' funcArg ( ',' funcArg )? ')' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:319:7: funcname '(' funcArg ( ',' funcArg )? ')'
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_funcname_in_funcCall2498);
            funcname167=funcname();

            state._fsp--;

            adaptor.addChild(root_0, funcname167.getTree());

            char_literal168=(Token)match(input,63,FOLLOW_63_in_funcCall2500); 
            char_literal168_tree = 
            (Object)adaptor.create(char_literal168)
            ;
            adaptor.addChild(root_0, char_literal168_tree);


            pushFollow(FOLLOW_funcArg_in_funcCall2502);
            funcArg169=funcArg();

            state._fsp--;

            adaptor.addChild(root_0, funcArg169.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:319:28: ( ',' funcArg )?
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==67) ) {
                alt29=1;
            }
            switch (alt29) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:319:30: ',' funcArg
                    {
                    char_literal170=(Token)match(input,67,FOLLOW_67_in_funcCall2506); 
                    char_literal170_tree = 
                    (Object)adaptor.create(char_literal170)
                    ;
                    adaptor.addChild(root_0, char_literal170_tree);


                    pushFollow(FOLLOW_funcArg_in_funcCall2508);
                    funcArg171=funcArg();

                    state._fsp--;

                    adaptor.addChild(root_0, funcArg171.getTree());

                    }
                    break;

            }


            char_literal172=(Token)match(input,64,FOLLOW_64_in_funcCall2514); 
            char_literal172_tree = 
            (Object)adaptor.create(char_literal172)
            ;
            adaptor.addChild(root_0, char_literal172_tree);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "funcCall"


    public static class funcname_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "funcname"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:322:1: funcname : ( FUNC_LOG | FUNC_EXP | FUNC_AGG_SINGLE | FUNC_GT_N_FAIL | POW | EXPRESS_TIME );
    public final RIIFParser.funcname_return funcname() throws RecognitionException {
        RIIFParser.funcname_return retval = new RIIFParser.funcname_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set173=null;

        Object set173_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:323:5: ( FUNC_LOG | FUNC_EXP | FUNC_AGG_SINGLE | FUNC_GT_N_FAIL | POW | EXPRESS_TIME )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:
            {
            root_0 = (Object)adaptor.nil();


            set173=(Token)input.LT(1);

            if ( input.LA(1)==EXPRESS_TIME||(input.LA(1) >= FUNC_AGG_SINGLE && input.LA(1) <= FUNC_LOG)||input.LA(1)==POW ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set173)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "funcname"


    public static class unaryExpressionNotPlusMinus_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "unaryExpressionNotPlusMinus"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:330:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | primary );
    public final RIIFParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus() throws RecognitionException {
        RIIFParser.unaryExpressionNotPlusMinus_return retval = new RIIFParser.unaryExpressionNotPlusMinus_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal174=null;
        Token char_literal176=null;
        RIIFParser.unaryExpression_return unaryExpression175 =null;

        RIIFParser.unaryExpression_return unaryExpression177 =null;

        RIIFParser.primary_return primary178 =null;


        Object char_literal174_tree=null;
        Object char_literal176_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:331:5: ( '~' unaryExpression | '!' unaryExpression | primary )
            int alt30=3;
            switch ( input.LA(1) ) {
            case 85:
                {
                alt30=1;
                }
                break;
            case 58:
                {
                alt30=2;
                }
                break;
            case Attr_ident:
            case DecimalLiteral:
            case EXPRESS_TIME:
            case FUNC_AGG_SINGLE:
            case FUNC_EXP:
            case FUNC_GT_N_FAIL:
            case FUNC_LOG:
            case FloatingPointLiteral:
            case GET_TRANSITION:
            case GET_TRANSITION_TIME:
            case GET_VALUE:
            case Hier_ident:
            case Ident:
            case POW:
            case StringLiteral:
            case UNIT_CDEGREES:
            case UNIT_FITS:
            case UNIT_VOLTS:
            case 63:
                {
                alt30=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;

            }

            switch (alt30) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:331:9: '~' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal174=(Token)match(input,85,FOLLOW_85_in_unaryExpressionNotPlusMinus2587); 
                    char_literal174_tree = 
                    (Object)adaptor.create(char_literal174)
                    ;
                    adaptor.addChild(root_0, char_literal174_tree);


                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus2589);
                    unaryExpression175=unaryExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, unaryExpression175.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:332:9: '!' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal176=(Token)match(input,58,FOLLOW_58_in_unaryExpressionNotPlusMinus2599); 
                    char_literal176_tree = 
                    (Object)adaptor.create(char_literal176)
                    ;
                    adaptor.addChild(root_0, char_literal176_tree);


                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus2601);
                    unaryExpression177=unaryExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, unaryExpression177.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:333:7: primary
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus2609);
                    primary178=primary();

                    state._fsp--;

                    adaptor.addChild(root_0, primary178.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "unaryExpressionNotPlusMinus"


    public static class unaryExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "unaryExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:336:1: unaryExpression : ( '+' unaryExpression | '-' unaryExpression | unaryExpressionNotPlusMinus );
    public final RIIFParser.unaryExpression_return unaryExpression() throws RecognitionException {
        RIIFParser.unaryExpression_return retval = new RIIFParser.unaryExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal179=null;
        Token char_literal181=null;
        RIIFParser.unaryExpression_return unaryExpression180 =null;

        RIIFParser.unaryExpression_return unaryExpression182 =null;

        RIIFParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus183 =null;


        Object char_literal179_tree=null;
        Object char_literal181_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:337:5: ( '+' unaryExpression | '-' unaryExpression | unaryExpressionNotPlusMinus )
            int alt31=3;
            switch ( input.LA(1) ) {
            case 66:
                {
                alt31=1;
                }
                break;
            case 68:
                {
                alt31=2;
                }
                break;
            case Attr_ident:
            case DecimalLiteral:
            case EXPRESS_TIME:
            case FUNC_AGG_SINGLE:
            case FUNC_EXP:
            case FUNC_GT_N_FAIL:
            case FUNC_LOG:
            case FloatingPointLiteral:
            case GET_TRANSITION:
            case GET_TRANSITION_TIME:
            case GET_VALUE:
            case Hier_ident:
            case Ident:
            case POW:
            case StringLiteral:
            case UNIT_CDEGREES:
            case UNIT_FITS:
            case UNIT_VOLTS:
            case 58:
            case 63:
            case 85:
                {
                alt31=3;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;

            }

            switch (alt31) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:337:9: '+' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal179=(Token)match(input,66,FOLLOW_66_in_unaryExpression2628); 
                    char_literal179_tree = 
                    (Object)adaptor.create(char_literal179)
                    ;
                    adaptor.addChild(root_0, char_literal179_tree);


                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression2630);
                    unaryExpression180=unaryExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, unaryExpression180.getTree());

                    }
                    break;
                case 2 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:338:9: '-' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal181=(Token)match(input,68,FOLLOW_68_in_unaryExpression2640); 
                    char_literal181_tree = 
                    (Object)adaptor.create(char_literal181)
                    ;
                    adaptor.addChild(root_0, char_literal181_tree);


                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression2642);
                    unaryExpression182=unaryExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, unaryExpression182.getTree());

                    }
                    break;
                case 3 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:339:9: unaryExpressionNotPlusMinus
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression2652);
                    unaryExpressionNotPlusMinus183=unaryExpressionNotPlusMinus();

                    state._fsp--;

                    adaptor.addChild(root_0, unaryExpressionNotPlusMinus183.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "unaryExpression"


    public static class additiveExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "additiveExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:342:1: additiveExpression : multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ;
    public final RIIFParser.additiveExpression_return additiveExpression() throws RecognitionException {
        RIIFParser.additiveExpression_return retval = new RIIFParser.additiveExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set185=null;
        RIIFParser.multiplicativeExpression_return multiplicativeExpression184 =null;

        RIIFParser.multiplicativeExpression_return multiplicativeExpression186 =null;


        Object set185_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:343:5: ( multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:343:9: multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression2671);
            multiplicativeExpression184=multiplicativeExpression();

            state._fsp--;

            adaptor.addChild(root_0, multiplicativeExpression184.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:343:34: ( ( '+' | '-' ) multiplicativeExpression )*
            loop32:
            do {
                int alt32=2;
                int LA32_0 = input.LA(1);

                if ( (LA32_0==66||LA32_0==68) ) {
                    alt32=1;
                }


                switch (alt32) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:343:36: ( '+' | '-' ) multiplicativeExpression
            	    {
            	    set185=(Token)input.LT(1);

            	    if ( input.LA(1)==66||input.LA(1)==68 ) {
            	        input.consume();
            	        adaptor.addChild(root_0, 
            	        (Object)adaptor.create(set185)
            	        );
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression2683);
            	    multiplicativeExpression186=multiplicativeExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, multiplicativeExpression186.getTree());

            	    }
            	    break;

            	default :
            	    break loop32;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "additiveExpression"


    public static class multiplicativeExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "multiplicativeExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:346:1: multiplicativeExpression : unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ;
    public final RIIFParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
        RIIFParser.multiplicativeExpression_return retval = new RIIFParser.multiplicativeExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set188=null;
        RIIFParser.unaryExpression_return unaryExpression187 =null;

        RIIFParser.unaryExpression_return unaryExpression189 =null;


        Object set188_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:347:5: ( unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:347:9: unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression2705);
            unaryExpression187=unaryExpression();

            state._fsp--;

            adaptor.addChild(root_0, unaryExpression187.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:347:25: ( ( '*' | '/' | '%' ) unaryExpression )*
            loop33:
            do {
                int alt33=2;
                int LA33_0 = input.LA(1);

                if ( (LA33_0==60||LA33_0==65||LA33_0==69) ) {
                    alt33=1;
                }


                switch (alt33) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:347:27: ( '*' | '/' | '%' ) unaryExpression
            	    {
            	    set188=(Token)input.LT(1);

            	    if ( input.LA(1)==60||input.LA(1)==65||input.LA(1)==69 ) {
            	        input.consume();
            	        adaptor.addChild(root_0, 
            	        (Object)adaptor.create(set188)
            	        );
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression2723);
            	    unaryExpression189=unaryExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, unaryExpression189.getTree());

            	    }
            	    break;

            	default :
            	    break loop33;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"


    public static class expression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:350:1: expression : conditionalExpression ;
    public final RIIFParser.expression_return expression() throws RecognitionException {
        RIIFParser.expression_return retval = new RIIFParser.expression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.conditionalExpression_return conditionalExpression190 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:351:5: ( conditionalExpression )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:351:7: conditionalExpression
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_conditionalExpression_in_expression2743);
            conditionalExpression190=conditionalExpression();

            state._fsp--;

            adaptor.addChild(root_0, conditionalExpression190.getTree());

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "expression"


    public static class conditionalExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "conditionalExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:353:1: conditionalExpression : conditionalOrExpression ( '?' conditionalExpression ':' conditionalExpression )? ;
    public final RIIFParser.conditionalExpression_return conditionalExpression() throws RecognitionException {
        RIIFParser.conditionalExpression_return retval = new RIIFParser.conditionalExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal192=null;
        Token char_literal194=null;
        RIIFParser.conditionalOrExpression_return conditionalOrExpression191 =null;

        RIIFParser.conditionalExpression_return conditionalExpression193 =null;

        RIIFParser.conditionalExpression_return conditionalExpression195 =null;


        Object char_literal192_tree=null;
        Object char_literal194_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:354:5: ( conditionalOrExpression ( '?' conditionalExpression ':' conditionalExpression )? )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:354:9: conditionalOrExpression ( '?' conditionalExpression ':' conditionalExpression )?
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression2758);
            conditionalOrExpression191=conditionalOrExpression();

            state._fsp--;

            adaptor.addChild(root_0, conditionalOrExpression191.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:354:33: ( '?' conditionalExpression ':' conditionalExpression )?
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==77) ) {
                alt34=1;
            }
            switch (alt34) {
                case 1 :
                    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:354:35: '?' conditionalExpression ':' conditionalExpression
                    {
                    char_literal192=(Token)match(input,77,FOLLOW_77_in_conditionalExpression2762); 
                    char_literal192_tree = 
                    (Object)adaptor.create(char_literal192)
                    ;
                    adaptor.addChild(root_0, char_literal192_tree);


                    pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression2764);
                    conditionalExpression193=conditionalExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, conditionalExpression193.getTree());

                    char_literal194=(Token)match(input,70,FOLLOW_70_in_conditionalExpression2766); 
                    char_literal194_tree = 
                    (Object)adaptor.create(char_literal194)
                    ;
                    adaptor.addChild(root_0, char_literal194_tree);


                    pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression2768);
                    conditionalExpression195=conditionalExpression();

                    state._fsp--;

                    adaptor.addChild(root_0, conditionalExpression195.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "conditionalExpression"


    public static class conditionalOrExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "conditionalOrExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:357:1: conditionalOrExpression : conditionalAndExpression ( '||' conditionalAndExpression )* ;
    public final RIIFParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
        RIIFParser.conditionalOrExpression_return retval = new RIIFParser.conditionalOrExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token string_literal197=null;
        RIIFParser.conditionalAndExpression_return conditionalAndExpression196 =null;

        RIIFParser.conditionalAndExpression_return conditionalAndExpression198 =null;


        Object string_literal197_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:358:5: ( conditionalAndExpression ( '||' conditionalAndExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:358:9: conditionalAndExpression ( '||' conditionalAndExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression2790);
            conditionalAndExpression196=conditionalAndExpression();

            state._fsp--;

            adaptor.addChild(root_0, conditionalAndExpression196.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:358:34: ( '||' conditionalAndExpression )*
            loop35:
            do {
                int alt35=2;
                int LA35_0 = input.LA(1);

                if ( (LA35_0==83) ) {
                    alt35=1;
                }


                switch (alt35) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:358:36: '||' conditionalAndExpression
            	    {
            	    string_literal197=(Token)match(input,83,FOLLOW_83_in_conditionalOrExpression2794); 
            	    string_literal197_tree = 
            	    (Object)adaptor.create(string_literal197)
            	    ;
            	    adaptor.addChild(root_0, string_literal197_tree);


            	    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression2796);
            	    conditionalAndExpression198=conditionalAndExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, conditionalAndExpression198.getTree());

            	    }
            	    break;

            	default :
            	    break loop35;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "conditionalOrExpression"


    public static class conditionalAndExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "conditionalAndExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:361:1: conditionalAndExpression : inclusiveOrExpression ( '&&' inclusiveOrExpression )* ;
    public final RIIFParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
        RIIFParser.conditionalAndExpression_return retval = new RIIFParser.conditionalAndExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token string_literal200=null;
        RIIFParser.inclusiveOrExpression_return inclusiveOrExpression199 =null;

        RIIFParser.inclusiveOrExpression_return inclusiveOrExpression201 =null;


        Object string_literal200_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:362:5: ( inclusiveOrExpression ( '&&' inclusiveOrExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:362:9: inclusiveOrExpression ( '&&' inclusiveOrExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2818);
            inclusiveOrExpression199=inclusiveOrExpression();

            state._fsp--;

            adaptor.addChild(root_0, inclusiveOrExpression199.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:362:31: ( '&&' inclusiveOrExpression )*
            loop36:
            do {
                int alt36=2;
                int LA36_0 = input.LA(1);

                if ( (LA36_0==61) ) {
                    alt36=1;
                }


                switch (alt36) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:362:33: '&&' inclusiveOrExpression
            	    {
            	    string_literal200=(Token)match(input,61,FOLLOW_61_in_conditionalAndExpression2822); 
            	    string_literal200_tree = 
            	    (Object)adaptor.create(string_literal200)
            	    ;
            	    adaptor.addChild(root_0, string_literal200_tree);


            	    pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2824);
            	    inclusiveOrExpression201=inclusiveOrExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, inclusiveOrExpression201.getTree());

            	    }
            	    break;

            	default :
            	    break loop36;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "conditionalAndExpression"


    public static class inclusiveOrExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "inclusiveOrExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:365:1: inclusiveOrExpression : exclusiveOrExpression ( '|' exclusiveOrExpression )* ;
    public final RIIFParser.inclusiveOrExpression_return inclusiveOrExpression() throws RecognitionException {
        RIIFParser.inclusiveOrExpression_return retval = new RIIFParser.inclusiveOrExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal203=null;
        RIIFParser.exclusiveOrExpression_return exclusiveOrExpression202 =null;

        RIIFParser.exclusiveOrExpression_return exclusiveOrExpression204 =null;


        Object char_literal203_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:366:5: ( exclusiveOrExpression ( '|' exclusiveOrExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:366:9: exclusiveOrExpression ( '|' exclusiveOrExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2846);
            exclusiveOrExpression202=exclusiveOrExpression();

            state._fsp--;

            adaptor.addChild(root_0, exclusiveOrExpression202.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:366:31: ( '|' exclusiveOrExpression )*
            loop37:
            do {
                int alt37=2;
                int LA37_0 = input.LA(1);

                if ( (LA37_0==82) ) {
                    alt37=1;
                }


                switch (alt37) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:366:33: '|' exclusiveOrExpression
            	    {
            	    char_literal203=(Token)match(input,82,FOLLOW_82_in_inclusiveOrExpression2850); 
            	    char_literal203_tree = 
            	    (Object)adaptor.create(char_literal203)
            	    ;
            	    adaptor.addChild(root_0, char_literal203_tree);


            	    pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2852);
            	    exclusiveOrExpression204=exclusiveOrExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, exclusiveOrExpression204.getTree());

            	    }
            	    break;

            	default :
            	    break loop37;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "inclusiveOrExpression"


    public static class exclusiveOrExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exclusiveOrExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:369:1: exclusiveOrExpression : andExpression ( '^' andExpression )* ;
    public final RIIFParser.exclusiveOrExpression_return exclusiveOrExpression() throws RecognitionException {
        RIIFParser.exclusiveOrExpression_return retval = new RIIFParser.exclusiveOrExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal206=null;
        RIIFParser.andExpression_return andExpression205 =null;

        RIIFParser.andExpression_return andExpression207 =null;


        Object char_literal206_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:370:5: ( andExpression ( '^' andExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:370:9: andExpression ( '^' andExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression2874);
            andExpression205=andExpression();

            state._fsp--;

            adaptor.addChild(root_0, andExpression205.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:370:23: ( '^' andExpression )*
            loop38:
            do {
                int alt38=2;
                int LA38_0 = input.LA(1);

                if ( (LA38_0==80) ) {
                    alt38=1;
                }


                switch (alt38) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:370:25: '^' andExpression
            	    {
            	    char_literal206=(Token)match(input,80,FOLLOW_80_in_exclusiveOrExpression2878); 
            	    char_literal206_tree = 
            	    (Object)adaptor.create(char_literal206)
            	    ;
            	    adaptor.addChild(root_0, char_literal206_tree);


            	    pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression2880);
            	    andExpression207=andExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, andExpression207.getTree());

            	    }
            	    break;

            	default :
            	    break loop38;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "exclusiveOrExpression"


    public static class andExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "andExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:373:1: andExpression : equalityExpression ( '&' equalityExpression )* ;
    public final RIIFParser.andExpression_return andExpression() throws RecognitionException {
        RIIFParser.andExpression_return retval = new RIIFParser.andExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token char_literal209=null;
        RIIFParser.equalityExpression_return equalityExpression208 =null;

        RIIFParser.equalityExpression_return equalityExpression210 =null;


        Object char_literal209_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:374:5: ( equalityExpression ( '&' equalityExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:374:9: equalityExpression ( '&' equalityExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_equalityExpression_in_andExpression2902);
            equalityExpression208=equalityExpression();

            state._fsp--;

            adaptor.addChild(root_0, equalityExpression208.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:374:28: ( '&' equalityExpression )*
            loop39:
            do {
                int alt39=2;
                int LA39_0 = input.LA(1);

                if ( (LA39_0==62) ) {
                    alt39=1;
                }


                switch (alt39) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:374:30: '&' equalityExpression
            	    {
            	    char_literal209=(Token)match(input,62,FOLLOW_62_in_andExpression2906); 
            	    char_literal209_tree = 
            	    (Object)adaptor.create(char_literal209)
            	    ;
            	    adaptor.addChild(root_0, char_literal209_tree);


            	    pushFollow(FOLLOW_equalityExpression_in_andExpression2908);
            	    equalityExpression210=equalityExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, equalityExpression210.getTree());

            	    }
            	    break;

            	default :
            	    break loop39;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "andExpression"


    public static class equalityExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "equalityExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:377:1: equalityExpression : instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ;
    public final RIIFParser.equalityExpression_return equalityExpression() throws RecognitionException {
        RIIFParser.equalityExpression_return retval = new RIIFParser.equalityExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set212=null;
        RIIFParser.instanceOfExpression_return instanceOfExpression211 =null;

        RIIFParser.instanceOfExpression_return instanceOfExpression213 =null;


        Object set212_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:378:5: ( instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:378:9: instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression2930);
            instanceOfExpression211=instanceOfExpression();

            state._fsp--;

            adaptor.addChild(root_0, instanceOfExpression211.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:378:30: ( ( '==' | '!=' ) instanceOfExpression )*
            loop40:
            do {
                int alt40=2;
                int LA40_0 = input.LA(1);

                if ( (LA40_0==59||LA40_0==75) ) {
                    alt40=1;
                }


                switch (alt40) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:378:32: ( '==' | '!=' ) instanceOfExpression
            	    {
            	    set212=(Token)input.LT(1);

            	    if ( input.LA(1)==59||input.LA(1)==75 ) {
            	        input.consume();
            	        adaptor.addChild(root_0, 
            	        (Object)adaptor.create(set212)
            	        );
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression2942);
            	    instanceOfExpression213=instanceOfExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, instanceOfExpression213.getTree());

            	    }
            	    break;

            	default :
            	    break loop40;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "equalityExpression"


    public static class instanceOfExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "instanceOfExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:381:1: instanceOfExpression : relationalExpression ;
    public final RIIFParser.instanceOfExpression_return instanceOfExpression() throws RecognitionException {
        RIIFParser.instanceOfExpression_return retval = new RIIFParser.instanceOfExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.relationalExpression_return relationalExpression214 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:382:5: ( relationalExpression )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:382:9: relationalExpression
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression2964);
            relationalExpression214=relationalExpression();

            state._fsp--;

            adaptor.addChild(root_0, relationalExpression214.getTree());

            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "instanceOfExpression"


    public static class relationalExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "relationalExpression"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:385:1: relationalExpression : additiveExpression ( relationalOp additiveExpression )* ;
    public final RIIFParser.relationalExpression_return relationalExpression() throws RecognitionException {
        RIIFParser.relationalExpression_return retval = new RIIFParser.relationalExpression_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        RIIFParser.additiveExpression_return additiveExpression215 =null;

        RIIFParser.relationalOp_return relationalOp216 =null;

        RIIFParser.additiveExpression_return additiveExpression217 =null;



        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:386:5: ( additiveExpression ( relationalOp additiveExpression )* )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:386:9: additiveExpression ( relationalOp additiveExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_additiveExpression_in_relationalExpression2983);
            additiveExpression215=additiveExpression();

            state._fsp--;

            adaptor.addChild(root_0, additiveExpression215.getTree());

            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:386:28: ( relationalOp additiveExpression )*
            loop41:
            do {
                int alt41=2;
                int LA41_0 = input.LA(1);

                if ( (LA41_0==73||LA41_0==76) ) {
                    alt41=1;
                }


                switch (alt41) {
            	case 1 :
            	    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:386:30: relationalOp additiveExpression
            	    {
            	    pushFollow(FOLLOW_relationalOp_in_relationalExpression2987);
            	    relationalOp216=relationalOp();

            	    state._fsp--;

            	    adaptor.addChild(root_0, relationalOp216.getTree());

            	    pushFollow(FOLLOW_additiveExpression_in_relationalExpression2989);
            	    additiveExpression217=additiveExpression();

            	    state._fsp--;

            	    adaptor.addChild(root_0, additiveExpression217.getTree());

            	    }
            	    break;

            	default :
            	    break loop41;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "relationalExpression"


    public static class relationalOp_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "relationalOp"
    // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:389:1: relationalOp : ( '<' | '>' );
    public final RIIFParser.relationalOp_return relationalOp() throws RecognitionException {
        RIIFParser.relationalOp_return retval = new RIIFParser.relationalOp_return();
        retval.start = input.LT(1);


        Object root_0 = null;

        Token set218=null;

        Object set218_tree=null;

        try {
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:390:5: ( '<' | '>' )
            // C:\\Datos\\asanchep\\research\\RelIIF\\RIIF.g:
            {
            root_0 = (Object)adaptor.nil();


            set218=(Token)input.LT(1);

            if ( input.LA(1)==73||input.LA(1)==76 ) {
                input.consume();
                adaptor.addChild(root_0, 
                (Object)adaptor.create(set218)
                );
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }
    // $ANTLR end "relationalOp"

    // Delegated rules


    protected DFA11 dfa11 = new DFA11(this);
    static final String DFA11_eotS =
        "\16\uffff";
    static final String DFA11_eofS =
        "\16\uffff";
    static final String DFA11_minS =
        "\1\51\1\44\1\106\1\44\1\107\1\121\1\107\2\uffff\1\44\1\103\1\44"+
        "\1\107\1\103";
    static final String DFA11_maxS =
        "\1\51\1\44\1\106\1\63\1\110\1\121\1\110\2\uffff\1\44\1\124\1\44"+
        "\1\110\1\124";
    static final String DFA11_acceptS =
        "\7\uffff\1\1\1\2\5\uffff";
    static final String DFA11_specialS =
        "\16\uffff}>";
    static final String[] DFA11_transitionS = {
            "\1\1",
            "\1\2",
            "\1\3",
            "\1\6\13\uffff\1\5\3\4",
            "\1\10\1\7",
            "\1\11",
            "\1\10\1\7",
            "",
            "",
            "\1\12",
            "\1\13\20\uffff\1\14",
            "\1\15",
            "\1\10\1\7",
            "\1\13\20\uffff\1\14"
    };

    static final short[] DFA11_eot = DFA.unpackEncodedString(DFA11_eotS);
    static final short[] DFA11_eof = DFA.unpackEncodedString(DFA11_eofS);
    static final char[] DFA11_min = DFA.unpackEncodedStringToUnsignedChars(DFA11_minS);
    static final char[] DFA11_max = DFA.unpackEncodedStringToUnsignedChars(DFA11_maxS);
    static final short[] DFA11_accept = DFA.unpackEncodedString(DFA11_acceptS);
    static final short[] DFA11_special = DFA.unpackEncodedString(DFA11_specialS);
    static final short[][] DFA11_transition;

    static {
        int numStates = DFA11_transitionS.length;
        DFA11_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA11_transition[i] = DFA.unpackEncodedString(DFA11_transitionS[i]);
        }
    }

    class DFA11 extends DFA {

        public DFA11(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 11;
            this.eot = DFA11_eot;
            this.eof = DFA11_eof;
            this.min = DFA11_min;
            this.max = DFA11_max;
            this.accept = DFA11_accept;
            this.special = DFA11_special;
            this.transition = DFA11_transition;
        }
        public String getDescription() {
            return "133:1: parameter_decl : ( PARAMETER ident ':' complex_type ';' -> ^( PARAMETER ident complex_type ) | PARAMETER ident ':' complex_type ':=' expression ';' -> ^( PARAMETER ident complex_type expression ) );";
        }
    }
 

    public static final BitSet FOLLOW_declaration_in_program660 = new BitSet(new long[]{0x0000880000020202L});
    public static final BitSet FOLLOW_component_decl_in_declaration678 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_environment_decl_in_declaration686 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_requirement_decl_in_declaration694 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_timeline_decl_in_declaration702 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMPONENT_in_component_decl724 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_component_decl726 = new BitSet(new long[]{0x0000000000080000L,0x0000000000000100L});
    public static final BitSet FOLLOW_EXTENDS_in_component_decl730 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_component_decl732 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_component_decl738 = new BitSet(new long[]{0x00000200004024B0L});
    public static final BitSet FOLLOW_component_body_element_in_component_decl740 = new BitSet(new long[]{0x00000200004024B0L});
    public static final BitSet FOLLOW_END_COMPONENT_in_component_decl745 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameter_decl_in_component_body_element791 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constant_decl_in_component_body_element798 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_child_component_decl_in_component_body_element805 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fail_mode_decl_in_component_body_element812 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignment_in_component_body_element819 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assertion_in_component_body_element827 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ENVIRONMENT_in_environment_decl844 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_environment_decl846 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_environment_decl848 = new BitSet(new long[]{0x0000020000004420L});
    public static final BitSet FOLLOW_environment_body_element_in_environment_decl850 = new BitSet(new long[]{0x0000020000004420L});
    public static final BitSet FOLLOW_END_ENVIRONMENT_in_environment_decl854 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameter_decl_in_environment_body_element890 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constant_decl_in_environment_body_element894 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignment_in_environment_body_element898 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_REQUIREMENT_in_requirement_decl915 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_requirement_decl917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_requirement_decl919 = new BitSet(new long[]{0x0000000000008010L});
    public static final BitSet FOLLOW_assertion_in_requirement_decl921 = new BitSet(new long[]{0x0000000000008010L});
    public static final BitSet FOLLOW_END_REQUIREMENT_in_requirement_decl925 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TIMELINE_in_timeline_decl943 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_timeline_decl945 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_timeline_decl947 = new BitSet(new long[]{0x0000500400010020L});
    public static final BitSet FOLLOW_timeline_body_element_in_timeline_decl949 = new BitSet(new long[]{0x0000500400010020L});
    public static final BitSet FOLLOW_END_TIMELINE_in_timeline_decl954 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_state_decl_in_timeline_body_element994 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignment_in_timeline_body_element998 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARAMETER_in_parameter_decl1016 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_parameter_decl1018 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_parameter_decl1020 = new BitSet(new long[]{0x000F001000000000L});
    public static final BitSet FOLLOW_complex_type_in_parameter_decl1022 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_parameter_decl1024 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PARAMETER_in_parameter_decl1046 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_parameter_decl1048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_parameter_decl1050 = new BitSet(new long[]{0x000F001000000000L});
    public static final BitSet FOLLOW_complex_type_in_parameter_decl1052 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_parameter_decl1055 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_expression_in_parameter_decl1057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_parameter_decl1060 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_env_parameter_decl1091 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_PARAMETER_in_env_parameter_decl1101 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_env_parameter_decl1103 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_env_parameter_decl1105 = new BitSet(new long[]{0x000F001000000000L});
    public static final BitSet FOLLOW_complex_type_in_env_parameter_decl1107 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000180L});
    public static final BitSet FOLLOW_71_in_env_parameter_decl1111 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_expression_in_env_parameter_decl1113 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_env_parameter_decl1119 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONSTANT_in_constant_decl1133 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_constant_decl1135 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_constant_decl1137 = new BitSet(new long[]{0x000E000000000000L});
    public static final BitSet FOLLOW_primitive_type_in_constant_decl1139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_constant_decl1141 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONSTANT_in_constant_decl1163 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_constant_decl1165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_constant_decl1167 = new BitSet(new long[]{0x000E000000000000L});
    public static final BitSet FOLLOW_primitive_type_in_constant_decl1169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
    public static final BitSet FOLLOW_71_in_constant_decl1172 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_expression_in_constant_decl1174 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_constant_decl1177 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CHILD_COMPONENT_in_child_component_decl1211 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_child_component_decl1213 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_child_component_decl1215 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_child_component_decl1217 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CHILD_COMPONENT_in_child_component_decl1238 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_child_component_decl1240 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_child_component_decl1242 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_vector_in_child_component_decl1244 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_child_component_decl1246 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FAIL_MODE_in_fail_mode_decl1273 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_fail_mode_decl1275 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_fail_mode_decl1277 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_special_state_in_state_decl1307 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_STATE_in_state_decl1309 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_state_decl1311 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_state_decl1313 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_state_decl1315 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STATE_in_state_decl1336 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_state_decl1338 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_state_decl1340 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_state_decl1342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSIGN_in_assignment1390 = new BitSet(new long[]{0x0000001200000040L});
    public static final BitSet FOLLOW_ident_in_assignment1394 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004400L});
    public static final BitSet FOLLOW_hier_ident_in_assignment1398 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004400L});
    public static final BitSet FOLLOW_attr_ident_in_assignment1402 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004400L});
    public static final BitSet FOLLOW_vector_in_assignment1406 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_74_in_assignment1410 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_expression_in_assignment1412 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_assignment1414 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_assertion1463 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_attr_ident_in_assertion1467 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001200L});
    public static final BitSet FOLLOW_relationalOp_in_assertion1471 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_expression_in_assertion1473 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_72_in_assertion1475 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TYPE_ENUM_in_enum_type1527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
    public static final BitSet FOLLOW_81_in_enum_type1529 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_enum_type1531 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100008L});
    public static final BitSet FOLLOW_67_in_enum_type1535 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_ident_in_enum_type1537 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100008L});
    public static final BitSet FOLLOW_84_in_enum_type1543 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Ident_in_user_type1556 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitive_type_in_complex_type1569 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enum_type_in_complex_type1573 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_user_type_in_complex_type1577 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_StringLiteral_in_literal2040 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_integerLiteral_in_literal2047 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FloatingPointLiteral_in_literal2054 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_units_in_literal2061 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DecimalLiteral_in_integerLiteral2073 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_integerLiteral_in_unitLiteral2085 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_FloatingPointLiteral_in_unitLiteral2087 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_UNDERSCORE_in_unitLiteral2090 = new BitSet(new long[]{0x00E0000000000000L});
    public static final BitSet FOLLOW_units_in_unitLiteral2092 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parExpression_in_primary2123 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_envCall_in_primary2132 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_timeCall_in_primary2141 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_funcCall_in_primary2150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primary2159 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ident_in_primary2168 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_hier_ident_in_primary2177 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_attr_ident_in_primary2186 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_envFunction_in_envCall2198 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_envCall2200 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_funcArg_in_envCall2202 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000009L});
    public static final BitSet FOLLOW_67_in_envCall2206 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_funcArg_in_envCall2208 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_envCall2214 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GET_VALUE_in_envFunction2225 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_timeFunction_in_timeCall2239 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_timeCall2241 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_funcArg_in_timeCall2243 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000009L});
    public static final BitSet FOLLOW_67_in_timeCall2247 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_funcArg_in_timeCall2249 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_timeCall2255 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Ident_in_ident2311 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Hier_ident_in_hier_ident2346 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Attr_ident_in_attr_ident2382 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_78_in_vector2403 = new BitSet(new long[]{0x0000001000001000L});
    public static final BitSet FOLLOW_DecimalLiteral_in_vector2406 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_ident_in_vector2408 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_vector2411 = new BitSet(new long[]{0x0000001000001000L});
    public static final BitSet FOLLOW_DecimalLiteral_in_vector2414 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
    public static final BitSet FOLLOW_ident_in_vector2416 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
    public static final BitSet FOLLOW_79_in_vector2419 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_63_in_parExpression2435 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_expression_in_parExpression2437 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_parExpression2439 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ident_in_funcArg2461 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_hier_ident_in_funcArg2465 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_attr_ident_in_funcArg2469 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_vector_in_funcArg2473 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_funcArg2485 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_funcname_in_funcCall2498 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_63_in_funcCall2500 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_funcArg_in_funcCall2502 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000009L});
    public static final BitSet FOLLOW_67_in_funcCall2506 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_funcArg_in_funcCall2508 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_funcCall2514 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_85_in_unaryExpressionNotPlusMinus2587 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus2589 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_58_in_unaryExpressionNotPlusMinus2599 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus2601 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_unaryExpressionNotPlusMinus2609 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_66_in_unaryExpression2628 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression2630 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_68_in_unaryExpression2640 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression2642 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression2652 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression2671 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000014L});
    public static final BitSet FOLLOW_set_in_additiveExpression2675 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression2683 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000014L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression2705 = new BitSet(new long[]{0x1000000000000002L,0x0000000000000022L});
    public static final BitSet FOLLOW_set_in_multiplicativeExpression2709 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression2723 = new BitSet(new long[]{0x1000000000000002L,0x0000000000000022L});
    public static final BitSet FOLLOW_conditionalExpression_in_expression2743 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalOrExpression_in_conditionalExpression2758 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L});
    public static final BitSet FOLLOW_77_in_conditionalExpression2762 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression2764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_70_in_conditionalExpression2766 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression2768 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression2790 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_83_in_conditionalOrExpression2794 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression2796 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2818 = new BitSet(new long[]{0x2000000000000002L});
    public static final BitSet FOLLOW_61_in_conditionalAndExpression2822 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression2824 = new BitSet(new long[]{0x2000000000000002L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2846 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_82_in_inclusiveOrExpression2850 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression2852 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression2874 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
    public static final BitSet FOLLOW_80_in_exclusiveOrExpression2878 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression2880 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression2902 = new BitSet(new long[]{0x4000000000000002L});
    public static final BitSet FOLLOW_62_in_andExpression2906 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression2908 = new BitSet(new long[]{0x4000000000000002L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression2930 = new BitSet(new long[]{0x0800000000000002L,0x0000000000000800L});
    public static final BitSet FOLLOW_set_in_equalityExpression2934 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression2942 = new BitSet(new long[]{0x0800000000000002L,0x0000000000000800L});
    public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression2964 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_additiveExpression_in_relationalExpression2983 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001200L});
    public static final BitSet FOLLOW_relationalOp_in_relationalExpression2987 = new BitSet(new long[]{0x84E02412F7841040L,0x0000000000200014L});
    public static final BitSet FOLLOW_additiveExpression_in_relationalExpression2989 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001200L});

}